From 19c02fef720cc59d25a84dfcd9eeb70adf8b73be Mon Sep 17 00:00:00 2001 From: anupras-mohapatra-arm Date: Thu, 25 Jun 2026 10:34:10 -0500 Subject: [PATCH 01/18] updates to account for summaries and faqs in metadata --- .github/skills/frontmatter-audit/SKILL.md | 3 ++- .github/skills/writing-style-review/SKILL.md | 4 ++-- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/.github/skills/frontmatter-audit/SKILL.md b/.github/skills/frontmatter-audit/SKILL.md index b62b68678d..ec0be2d0ec 100644 --- a/.github/skills/frontmatter-audit/SKILL.md +++ b/.github/skills/frontmatter-audit/SKILL.md @@ -25,13 +25,14 @@ For a Learning Path directory: - Public pages should have unique `weight` values within the directory. - Every page except for `_next-steps.md` must include a description. - `_index.md` must include `description`. -- Required `_index.md` fields include `title`, `description`, `weight`, `layout`, `minutes_to_complete`, `prerequisites`, `author`, `subjects`, `armips`, `tools_software_languages`, `skilllevels`, and `operatingsystems`. +- Required `_index.md` fields include `title`, `description`, `weight`, `layout`, `minutes_to_complete`, `prerequisites`, `author`, `generate_summary_faq`, `rerun_summary`, `rerun_faqs`, `subjects`, `armips`, `tools_software_languages`, `skilllevels`, and `operatingsystems`. - `layout` is usually `learningpathall`. - `title` should be task-led and use an imperative structure: verb + technology/tool + outcome. - `skilllevels` values are only `Introductory` or `Advanced`. - `subjects` and `operatingsystems` must match the closed lists in `content/learning-paths/cross-platform/_example-learning-path/write-2-metadata/`. - `armips` should use Arm IP families such as Neoverse, Cortex-A, or Cortex-M, not specific CPU models or Arm architecture versions. - `author` can list multiple authors with YAML list syntax. +- `generate_summary_faq`, `rerun_summary`, and `rerun_faqs` values are only `true` and `false`. - Skip `_next-steps.md` for description updates unless the user explicitly asks how to handle it. ## Install guide checks diff --git a/.github/skills/writing-style-review/SKILL.md b/.github/skills/writing-style-review/SKILL.md index a980254b01..e7ffbc52f5 100644 --- a/.github/skills/writing-style-review/SKILL.md +++ b/.github/skills/writing-style-review/SKILL.md @@ -74,7 +74,7 @@ Use this skill for granular prose, voice, readability, terminology, and style re - Use `set up` as a verb and `setup` as a noun. - Use `avoid` instead of `try not to`. - Use `such as` instead of `like`. -- Use `after` instead of `once`. +- Use `after` or `when` instead of `once`. ## Tone cleanup @@ -111,7 +111,7 @@ Use this skill for granular prose, voice, readability, terminology, and style re - Use `arm64` or `aarch64` for CPU architecture based on tool, package, or OS convention. - Use `ARM64` only when referring to Windows on Arm or Microsoft documentation. - Capitalize `Learning Path`. -- Use `Azure Cobalt`, `Google Axion`, and `AWS Graviton` as processor names, not VM names. +- Use `Azure Cobalt`, `Google Axion`, and `AWS Graviton` as processor names, not VM names. `Graviton-based instances`, not `Graviton instances`, for example. - Do not use bold or italics for product names such as LiteRT, XNNPACK, KleidiAI, and SME2 unless they are headings or UI labels. ## Avoid AI-sounding prose From fd763d56b00a052281ac3f1628818e5f959df185 Mon Sep 17 00:00:00 2001 From: anupras-mohapatra-arm Date: Thu, 25 Jun 2026 10:42:26 -0500 Subject: [PATCH 02/18] more updates for summaries and faqs --- .github/skills/writing-style-review/SKILL.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/skills/writing-style-review/SKILL.md b/.github/skills/writing-style-review/SKILL.md index e7ffbc52f5..cf631a0227 100644 --- a/.github/skills/writing-style-review/SKILL.md +++ b/.github/skills/writing-style-review/SKILL.md @@ -18,8 +18,8 @@ Use this skill for granular prose, voice, readability, terminology, and style re ## Voice and tone -- Use second person: `you` and `your`. -- Avoid first person: `I` and `we`. +- Use second person: `you` and `your` for Learning Path summaries, Learning Path content, install guide content, answers to FAQs, and metadata descriptions. Avoid first person for these content types. +- Use first person: `I` and `we` for FAQs. - Use active voice. - Use present tense for descriptions. - Use imperative mood for commands. From b576709742d8c5a536cf72f89e32136def9a22cc Mon Sep 17 00:00:00 2001 From: anupras-mohapatra-arm Date: Thu, 25 Jun 2026 12:24:52 -0500 Subject: [PATCH 03/18] first pass refactor of performance studio LP --- .../mobile-graphics-and-gaming/ams/_index.md | 9 ++-- .../mobile-graphics-and-gaming/ams/ams.md | 38 ++++++++++--- .../mobile-graphics-and-gaming/ams/fa.md | 31 ++++++----- .../mobile-graphics-and-gaming/ams/malioc.md | 12 ++++- .../mobile-graphics-and-gaming/ams/pa.md | 29 +++++----- .../ams/pa_example.md | 15 ++++-- .../ams/renderdoc.md | 17 +++--- .../ams/setup_tasks.md | 53 ++++++++----------- .../ams/streamline.md | 11 +++- .../ams/streamline_example.md | 19 ++++--- 10 files changed, 151 insertions(+), 83 deletions(-) diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/_index.md b/content/learning-paths/mobile-graphics-and-gaming/ams/_index.md index 3a9b8533fb..6a3e97f78b 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/_index.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/_index.md @@ -1,14 +1,17 @@ --- -title: Get started with Arm Performance Studio +title: Profile an Android application with Arm Performance Studio description: Learn how to use each of the tools supplied with Arm Performance Studio (formerly known as Arm Mobile Studio). minutes_to_complete: 60 -who_is_this_for: Android application and games developers new to Arm Performance Studio. +who_is_this_for: This is an introductory topic for Android application and games developers new to Arm Performance Studio. learning_objectives: - - Learn the basic features of each component of Arm Performance Studio. + - Capture a Streamline profile from a debuggable Android application + - Generate and inspect a Performance Advisor report + - Capture and analyze a frame with Frame Advisor and RenderDoc for Arm GPUs + - Use Mali Offline Compiler to estimate shader cost - Get started profiling and optimizing your application. prerequisites: diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/ams.md b/content/learning-paths/mobile-graphics-and-gaming/ams/ams.md index 6db0edfda6..fd875867b8 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/ams.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/ams.md @@ -1,13 +1,15 @@ --- # User change -title: "What is Arm Performance Studio?" +title: Set up Arm Performance Studio weight: 2 # 1 is first, 2 is second, etc. # Do not modify these elements layout: "learningpathall" --- -[Arm Performance Studio](https://developer.arm.com/Tools%20and%20Software/Arm%20Performance%20Studio) is a performance analysis tool suite for developers to performance test their applications on devices with Mali-based GPUs. It consists of 4 easy-to-use tools that show you how well your application performs either on off-the-shelf Android devices, or Linux targets. The tools help you to identify problems that might slow down performance, overheat the device, or drain the battery. +## What is Arm Performance Studio? + +[Arm Performance Studio](https://developer.arm.com/Tools%20and%20Software/Arm%20Performance%20Studio) is a performance analysis tool suite for developers to performance test their applications on devices with Mali-based GPUs. It consists of four easy-to-use tools that show you how well your application performs either on off-the-shelf Android devices, or Linux targets. The tools help you to identify problems that might slow down performance, overheat the device, or drain the battery. | Component | Functionality | |----------|-------------| @@ -16,11 +18,29 @@ layout: "learningpathall" | [Mali Offline Compiler](https://developer.arm.com/Tools%20and%20Software/Mali%20Offline%20Compiler) | Analyze how efficiently your shader programs perform on a range of Mali GPUs. | | [RenderDoc for Arm GPUs](https://developer.arm.com/Tools%20and%20Software/RenderDoc%20for%20Arm%20GPUs) | The industry-standard tool for debugging Vulkan graphics applications, including early support for Arm GPU extensions and Android features. | -## Download and Install Arm Performance Studio +## Download and install Arm Performance Studio + +Arm Performance Studio is supported on Windows, Linux, and macOS hosts. To download Arm Performance Studio, see the [Arm Performance Studio downloads page](https://developer.arm.com/Tools%20and%20Software/Arm%20Performance%20Studio#Downloads). + +For installation instructions, see the [Arm Performance Studio install guide](/install-guides/ams/). + +## Update your PATH environment variable (Linux and macOS) + +Edit your `PATH` environment variable to add the paths to the Streamline and Mali Offline Compiler executables. This is so that you can run Streamline's `Streamline-cli -pa` command and Mali Offline Compiler's `malioc` command from any directory. This step is not necessary on Windows, as this is done automatically when Arm Performance Studio is installed. -Arm Performance Studio is supported on Windows, Linux, and macOS hosts. Get the [Arm Performance Studio installation package](https://developer.arm.com/Tools%20and%20Software/Arm%20Performance%20Studio#Downloads). +On macOS, edit your `/etc/paths` file to add the following paths: -Refer to the [Arm Performance Studio install guide](/install-guides/ams/) for installation instructions. +``` +//streamline +//mali_offline_compiler +``` + +On Linux, edit your `PATH` environment variable to add the paths to the Performance Advisor executable. Add this command to the `.bashrc` file in your home directory, so that this environment variable is set whenever you initialize a shell session. + +``` + PATH=$PATH://streamline + PATH=$PATH://mali_offline_compiler +``` ## Launch the tools @@ -29,4 +49,10 @@ To open the tools, launch the Performance Studio Hub: - On Windows, search for Performance Studio. - On macOS and Linux, open the Performance Studio application file from the install directory. - ![Performance Studio Hub](images/ps_hub.png) +![Performance Studio Hub](images/ps_hub.png) + +## What you've accomplished and what's next + +You've now set up Arm Performance Studio and updated your PATH environment variable so you can use suite of available tools to profile applications. + +Next, you'll set up the application that you'll profile in this Learning Path. \ No newline at end of file diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/fa.md b/content/learning-paths/mobile-graphics-and-gaming/ams/fa.md index 5d83889000..9819a628e1 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/fa.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/fa.md @@ -1,19 +1,18 @@ --- # User change -title: "Frame Advisor" +title: "Analyze your application with Frame Advisor" weight: 8 # 1 is first, 2 is second, etc. # Do not modify these elements layout: "learningpathall" --- -[Frame Advisor](https://developer.arm.com/Tools%20and%20Software/Frame%20Advisor) offers in-depth frame-based analysis for mobile graphics in Android applications. By capturing the API calls and rendering processes of a specific frame, you can identify potential performance bottlenecks that may be causing slowdowns in your application. -## Prerequisites +## Connect to your Android device -Build your application, and setup the Android device as described in [Setup tasks](/learning-paths/mobile-graphics-and-gaming/ams/setup_tasks/). +[Frame Advisor](https://developer.arm.com/Tools%20and%20Software/Frame%20Advisor) offers in-depth frame-based analysis for mobile graphics in Android applications. By capturing the API calls and rendering processes of a specific frame, you can identify potential performance bottlenecks that may be causing slowdowns in your application. -## Connect to the device +Start by connecting to your device. 1. Launch the Performance Studio Hub and open Frame Advisor. - On Windows, search for Performance Studio. @@ -21,33 +20,35 @@ Build your application, and setup the Android device as described in [Setup task ![Performance Studio Hub](images/ps_hub.png) -1. Select `New trace` to start a new trace. +2. Select `New trace` to start a new trace. ![Frame Advisor launch screen](images/fa_launch_screen.png) -1. Select your device, and the application that you want to capture frames from. +3. Select your device, and the application that you want to capture frames from. ![Device connection screen](images/fa_connect.png) -1. If your application uses the Vulkan API, change the selection in the API settings to `Vulkan`. +4. If your application uses the Vulkan API, change the selection in the API settings to `Vulkan`. -1. Click `Next` to continue. +5. Click `Next` to continue. Unless you chose the `Pause on connect` option in the `Device connection` screen, the application starts automatically on the device. ## Capture a frame burst +After connecting to your device, you can capture a frame burst. + 1. The `Capture` screen provides options for your capture session. ![Frame Advisor capture screen](images/fa_capture.png) When you approach the part of your game where the problem occurs, click `Pause` and use the `Step` button to focus in just before it. -1. You can capture one frame burst of up to 3 consecutive frames. Adjust the `Frame count` as required. +2. You can capture one frame burst of up to 3 consecutive frames. Adjust the `Frame count` as required. -1. Click the `Capture` button to start capturing the frame burst. Wait for the capture to complete. This may take several seconds. +3. Click the `Capture` button to start capturing the frame burst. Wait for the capture to complete. This may take several seconds. -1. Click `Analyze` to see the results. It may take a few minutes to analyze the data. +4. Click `Analyze` to see the results. It may take a few minutes to analyze the data. ## Analyze the capture @@ -76,3 +77,9 @@ Explore each frame to evaluate how efficiently they were rendered on the device. ![Detailed Metrics view](images/fa_detailed_metrics_view.png) Watch this [video tutorial](https://developer.arm.com/Additional%20Resources/Video%20Tutorials/Capture%20and%20analyze%20a%20problem%20frame%20with%20Frame%20Advisor) to see how to capture and analyze a problem frame with Frame Advisor. + +## What you've accomplished and what's next + +You've now analyzed your application with Frame Advisor. + +Next, you'll use RenderDoc for Arm GPUs to capture frames and select application events for debugging. \ No newline at end of file diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md b/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md index 54bc14ba31..0994ab882d 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md @@ -1,12 +1,15 @@ --- # User change -title: "Mali Offline Compiler" +title: Generate a performance report with Mali Offline Compiler weight: 10 # 1 is first, 2 is second, etc. # Do not modify these elements layout: "learningpathall" --- + +## Before you begin + Mali Offline Compiler is a command-line tool that you can use to compile all shaders and kernels from OpenGL ES and Vulkan, and generate a performance report for the GPU of interest. In a terminal, test that Mali Offline Compiler is installed correctly, by typing: @@ -134,3 +137,10 @@ A = Arithmetic, LS = Load/Store, V = Varying, T = Texture Observe that the number of `Arithmetic` cycles has been significantly reduced. Understanding the output of the report is key to the usefulness of the Mali Offline Compiler. This brief [video tutorial](https://developer.arm.com/Additional%20Resources/Video%20Tutorials/Arm%20Mali%20GPU%20Training%20-%20EP3-5) is an excellent starter. + +## What you've accomplished + +You've used Mali Offline Compiler to analyze shader performance on a Mali-based GPU of interest. + +You can use the components and workflows described in this Learning Path to profile your applications and analyze performance using Arm Performance Studio. + diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/pa.md b/content/learning-paths/mobile-graphics-and-gaming/ams/pa.md index be3098a655..aa6ab7e1ba 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/pa.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/pa.md @@ -1,12 +1,15 @@ --- # User change -title: "Performance Advisor with your application" +title: Create a Performance Advisor report for your application weight: 7 # 1 is first, 2 is second, etc. # Do not modify these elements layout: "learningpathall" --- + +## Connect to Android device and collect frame data + Now that you have seen a [Performance Advisor example report](/learning-paths/mobile-graphics-and-gaming/ams/pa_example/), you can use it to capture data from your own application. Performance Advisor runs on a Streamline capture file, so the first step is to take a capture with Streamline. Streamline must capture extra frame data from the device, which Performance Advisor needs to generate a report. To capture the extra frame data, you must first run the provided Python script, `streamline_me.py`. @@ -17,13 +20,7 @@ This script does the following: * Temporarily installs the OpenGL ES or Vulkan layer library file on your device, which is needed to collect frame data. * Enables you to specify options for the capture, such as whether to collect screenshots when the FPS drops below a certain threshold. -## Before you begin - -Performance Advisor uses a Python script to connect to your device. You will need `Python 3.8` or later installed on your host machine. - -Build your application, and setup the Android device as described in [Setup tasks](/learning-paths/mobile-graphics-and-gaming/ams/setup_tasks/). - -## Connect to the device +To connect to the Android device and capture frame data, follow these steps: 1. Open a terminal or command prompt, navigate to the `Arm Performance Studio` install directory and locate the `streamline_me.py` script: @@ -31,7 +28,7 @@ Build your application, and setup the Android device as described in [Setup task cd /streamline/bin/android ``` -1. Run the script, enabling frame boundaries, with: +2. Run the script, enabling frame boundaries, with: ```console python3 streamline_me.py --lwi-mode=counters @@ -41,7 +38,7 @@ Build your application, and setup the Android device as described in [Setup task To see all available options, use `python3 streamline_me.py --help` {{% /notice %}} -1. The script returns a numbered list of the Android package names for the debuggable applications that are installed on your device. Enter the number of the application you want to profile. +3. The script returns a numbered list of the Android package names for the debuggable applications that are installed on your device. Enter the number of the application you want to profile. ```python Searching for devices: @@ -64,7 +61,9 @@ To see all available options, use `python3 streamline_me.py --help` The script identifies the GPU in the device, installs the daemon application and layer library, then waits for you to complete the capture in Streamline. -1. Leave the terminal window open, as you need to come back to it after the capture is complete, to stop the script. When the script ends, any captured screenshots are saved to the directory you specified, and the daemon application and layer library are uninstalled from the device. Do not unplug the device until the script has ended. +{{% notice Note %}} +Leave the terminal window open, as you need to come back to it after the capture is complete, to stop the script. When the script ends, any captured screenshots are saved to the directory you specified, and the daemon application and layer library are uninstalled from the device. Do not unplug the device until the script has ended. +{{% /notice %}} See the [Get started with Performance Advisor Tutorial](https://developer.arm.com/documentation/102478/latest/Run-the-streamline-me-py-script) for full instructions. @@ -113,6 +112,12 @@ This feature is particularly useful when used within a [CI workflow](https://dev streamline-cli -pa --type=json:report.json my_capture.apc ``` -## Performance budgets +## Specify performance budgets You can specify a performance budget which will be reflected in the Performance Advisor report. For more information, refer to the [Performance Advisor User Guide](https://developer.arm.com/documentation/102009/latest/Quick-start-guide/Setting-performance-budgets) section on performance budgets. + +## What you've accomplished and what's next + +You've now generated JSON and HTML performance Performance Advisor reports for your application. + +Next, you'll perform frame-based analysis on your application using Frame Advisor. diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/pa_example.md b/content/learning-paths/mobile-graphics-and-gaming/ams/pa_example.md index ef80a4fa31..a48b3280f5 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/pa_example.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/pa_example.md @@ -1,17 +1,18 @@ --- # User change -title: "Performance Advisor example report " +title: View an example Performance Advisor report weight: 6 # 1 is first, 2 is second, etc. # Do not modify these elements layout: "learningpathall" --- -Performance Advisor creates an easy-to-read report from a Streamline capture. This helps you quickly understand how your Android application performed on a mobile device. ## Generate a performance report -The supplied [Arm Streamline example capture](/learning-paths/mobile-graphics-and-gaming/ams/streamline_example/) can be used to generate a `Performance Advisor` report. +Performance Advisor creates an easy-to-read report from a Streamline capture that you can use to understand how your Android application performs on a mobile device. + +You can use the [Arm Streamline example capture](/learning-paths/mobile-graphics-and-gaming/ams/streamline_example/) that comes with Arm Performance Studio to generate an example `Performance Advisor` report. 1. Open a terminal, and navigate to the location of the imported capture. @@ -33,4 +34,10 @@ The supplied [Arm Streamline example capture](/learning-paths/mobile-graphics-an ## Evaluate the report -Refer to the [Performance Advisor tutorial](https://developer.arm.com/documentation/102478/latest/Example-Performance-Advisor-report) for a detailed explanation about the charts in the report. +For a detailed explanation on how to interpret the report, see the [Example Performance Advisor report tutorial](https://developer.arm.com/documentation/102478/latest/Example-Performance-Advisor-report) in Arm documentation. + +## What you've accomplished and what's next + +You've now created a performance report from the example Streamline capture that's packaged with Arm Performance Studio to understand the workflow for report creation. + +Next, you'll create a report for your application. diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/renderdoc.md b/content/learning-paths/mobile-graphics-and-gaming/ams/renderdoc.md index f5e529c70b..3541bbd8bb 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/renderdoc.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/renderdoc.md @@ -1,19 +1,18 @@ --- # User change -title: "RenderDoc for Arm GPUs" +title: Debug your application with RenderDoc for Arm GPUs weight: 9 # 1 is first, 2 is second, etc. # Do not modify these elements layout: "learningpathall" --- -[RenderDoc for Arm GPUs](https://developer.arm.com/Tools%20and%20Software/RenderDoc%20for%20Arm%20GPUs) is an Arm fork of the [RenderDoc](https://renderdoc.org/) open-source debugger. The Arm release includes support for API features and extensions that are available on the latest Arm GPUs, but not yet supported in upstream RenderDoc. Arm intends to contribute changes to the upstream project, but some Arm-specific or Android-specific features may only be available in the Arm fork. -## Prerequisites +## Run RenderDoc for Arm GPUs -Build your application, and setup the Android device as described in [Setup tasks](/learning-paths/mobile-graphics-and-gaming/ams/setup_tasks/). +[RenderDoc for Arm GPUs](https://developer.arm.com/Tools%20and%20Software/RenderDoc%20for%20Arm%20GPUs) is an Arm fork of the [RenderDoc](https://renderdoc.org/) open-source debugger. The Arm release includes support for API features and extensions that are available on the latest Arm GPUs, but not yet supported in upstream RenderDoc. Arm intends to contribute changes to the upstream project, but some Arm-specific or Android-specific features might be available only in the Arm fork. -## Connect to the device +To run RenderDoc for Arm GPUs, follow these steps: 1. Open RenderDoc for Arm GPUs and select your connected device from the **Replay Context** dropdown list at the bottom left of the RenderDoc UI. @@ -49,4 +48,10 @@ Build your application, and setup the Android device as described in [Setup task Selected events are highlighted with a green flag. All the other windows in the UI update to display information that is specific to the selected event. You can use this to view the render state and data resources that are used by the current event, and view the GPU output that resulted from it. -See the [RenderDoc documentation](https://renderdoc.org/docs/index.html#) to explore the full list of features. \ No newline at end of file +See the [RenderDoc documentation](https://renderdoc.org/docs/index.html#) to explore the full list of features. + +## What you've accomplished and what's next + +You've now run RenderDoc for Arm GPUs on your application and learned how to capture frames and select events for debugging. + +Next, you'll run Mali Offline Compiler to compile shaders and generate performance reports. \ No newline at end of file diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/setup_tasks.md b/content/learning-paths/mobile-graphics-and-gaming/ams/setup_tasks.md index 4efb4d6f45..2c184c5bc2 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/setup_tasks.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/setup_tasks.md @@ -1,44 +1,27 @@ --- # User change -title: "Setup tasks" +title: Set up the Android application weight: 3 # 1 is first, 2 is second, etc. # Do not modify these elements layout: "learningpathall" --- -## Installation +## Before you begin -1. Install Arm Performance Studio by following the instructions in the [Arm Performance Studio install guide](/install-guides/ams/). Details about changes since the last release can be found in the [Release Note](https://developer.arm.com/documentation/107649/latest/). -1. Ensure you have installed [Android Debug Bridge (adb)](https://developer.android.com/studio/command-line/adb). `adb` is available with the Android SDK platform tools, which are installed as part of Android Studio. Alternatively, you can download them separately as part of the Android SDK platform tools. -1. Performance Advisor uses a Python script to connect to your device. To run this script, you will need [Python](https://www.python.org/downloads/) 3.8 or later installed. - -## Update your PATH environment variable (Linux and macOS) - -Edit your `PATH` environment variable to add the paths to the Streamline and Mali Offline Compiler executables. This is so that you can run Streamline's `Streamline-cli -pa` command and Mali Offline Compiler's `malioc` command from any directory. This step is not necessary on Windows, as this is done automatically when Arm Performance Studio is installed. - -On macOS, edit your `/etc/paths` file to add the following paths: - -``` -//streamline -//mali_offline_compiler -``` - -On Linux, edit your `PATH` environment variable to add the paths to the Performance Advisor executable. Add this command to the `.bashrc` file in your home directory, so that this environment variable is set whenever you initialize a shell session. +Complete the following prerequisites: - ``` - PATH=$PATH://streamline - PATH=$PATH://mali_offline_compiler -``` +1. Ensure you have installed [Android Debug Bridge (adb)](https://developer.android.com/studio/command-line/adb). `adb` is available with the Android SDK platform tools, which are installed as part of Android Studio. Alternatively, you can download them separately as part of the Android SDK platform tools. +2. Performance Advisor uses a Python script to connect to your device. To run this script, you'll need [Python](https://www.python.org/downloads/) 3.8 or later installed. ## Build your application -The application must be compiled with debug enabled, as well as additional options to facilitate call stack unwinding by Streamline. +You need to compile the application with debug enabled, as well as additional options to facilitate call stack unwinding by Streamline. -* To set [Unity](https://unity.com/) applications to be debuggable, enable [Development Build](https://docs.unity3d.com/6000.0/Documentation/Manual/android-BuildProcess.html) in `Build settings`. -* In Android Studio, use a build variant that includes `debuggable true` (`isDebuggable = true` in Kotlin scripts) in the build configuration. -* In Unreal Engine, open `Project Settings > Project > Packaging > Project`, and ensure that the `For Distribution` checkbox is not set. -* For C++ or Java applications, refer to the [Target setup guide for Android](https://developer.arm.com/documentation/101813/latest/Target-Setup/Compile-your-application) for instructions on how to compile your application with the right options. +- To set [Unity](https://unity.com/) applications to be debuggable, enable [Development Build](https://docs.unity3d.com/6000.0/Documentation/Manual/android-BuildProcess.html) in `Build settings`. +- In Android Studio, use a build variant that includes `debuggable true` (`isDebuggable = true` in Kotlin scripts) in the build configuration. +- In Unreal Engine, open `Project Settings > Project > Packaging > Project`, and ensure that the `For Distribution` checkbox is not set. +- For instructions on how to complie your C++ or Java applications with the right options, see the [Target setup guide for Android](https://developer.arm.com/documentation/101813/latest/Target-Setup/Compile-your-application). {{% notice Tip %}} To assist with readability and add context, you can optionally include [annotations](https://developer.arm.com/documentation/101816/latest/Annotate-your-code/Add-annotations-to-your-code) in your code, which are then displayed in Streamline. @@ -46,10 +29,12 @@ To assist with readability and add context, you can optionally include [annotati ## Set up the Android device +To set up your Android device, follow these steps: + 1. On the device, ensure that [Developer Mode](https://developer.android.com/studio/debug/dev-options) is enabled. -1. Enable `USB Debugging` under `Settings > Developer options`. If your device asks you to authorize connection to your computer, confirm the connection. -1. Connect the device to the host through USB and approve the debug connection on the device when prompted. -1. To test the connection, run the `adb devices` command in a command terminal. If successful, this returns the ID of your device: +2. Enable `USB Debugging` under `Settings > Developer options`. If your device asks you to authorize connection to your computer, confirm the connection. +3. Connect the device to the host through USB and approve the debug connection on the device when prompted. +4. To test the connection, run the `adb devices` command in a command terminal. If successful, this returns the ID of your device: ```command adb devices @@ -59,4 +44,10 @@ To assist with readability and add context, you can optionally include [annotati If you see that the device is listed as `unauthorized`, try disabling and re-enabling `USB Debugging` on the device, and accept the authorization prompt to enable connection to the computer. -1. Install the [debuggable](https://developer.android.com/studio/debug) application on the device. +5. Install the [debuggable](https://developer.android.com/studio/debug) application on the device. + +## What you've accomplished and what's next + +You've now set up your Android device and built the application you'll use for profiling. + +Next, you'll look at an example Arm Streamline report to understand the Streamline component of Arm Performance Studio. \ No newline at end of file diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/streamline.md b/content/learning-paths/mobile-graphics-and-gaming/ams/streamline.md index e6de786905..f688c34c47 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/streamline.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/streamline.md @@ -1,16 +1,17 @@ --- # User change -title: "Streamline with your application" +title: Use Arm Streamline to capture data for your application weight: 5 # 1 is first, 2 is second, etc. # Do not modify these elements layout: "learningpathall" --- -Now that you have seen an [Arm Streamline example capture](/learning-paths/mobile-graphics-and-gaming/ams/streamline_example/), you can use it to capture data from your own application. ## Select the device and application in Streamline +Now that you have seen an [Arm Streamline example capture](/learning-paths/mobile-graphics-and-gaming/ams/streamline_example/), you can use it to capture data from your own application. + 1. Launch the Performance Studio Hub and open Streamline. - On Windows, search for Performance Studio. @@ -45,3 +46,9 @@ Streamline will stop capturing data, remove the daemon, and process the captured The charts in the `Timeline` view show the performance counter activity captured from the device. Hover over the charts to see the values at that point in time. Use the Calipers to focus on particular windows of activity. Refer to the [Streamline User Guide](https://developer.arm.com/documentation/101816/latest/Analyze-your-capture) for full instructions on how to use the features in the `Timeline` view. Understanding the output of Streamline is key to the usefulness of Streamline. The documentation for [Android performance triage with Streamline](https://developer.arm.com/documentation/102540/latest/) on Arm Developer describes how to understand the capture from a number of points of view, depending on what information you are trying to extract from it. + +## What you've accomplished and what's next + +You've now generated and analyzed an Arm Streamline report for your application. + +Next, you'll view an example Performance Advisor report. \ No newline at end of file diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/streamline_example.md b/content/learning-paths/mobile-graphics-and-gaming/ams/streamline_example.md index 0073e1364d..e8703d0e5b 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/streamline_example.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/streamline_example.md @@ -1,26 +1,25 @@ --- # User change -title: "Arm Streamline example capture" +title: Interpret an example Arm Streamline report weight: 4 # 1 is first, 2 is second, etc. # Do not modify these elements layout: "learningpathall" --- -This learning path explores Streamline for Android application profiling on a mobile device. For other use cases, refer to the supporting materials for [Arm Development Studio](https://developer.arm.com/Tools%20and%20Software/Arm%20Development%20Studio). -## Example Streamline report +## View the example Arm Streamline report To help you understand the capabilities of Streamline, an example Streamline profile is provided with Arm Performance Studio. 1. To open the example profile, in Streamline, select `File` > `Import`. -1. Select `Import Streamline Sample Captures` and click `Next`. +2. Select `Import Streamline Sample Captures` and click `Next`. ![Import #center](images/import.png "Import Streamline Sample Captures") -1. Select the Android example and click `Finish`. +3. Select the Android example and click `Finish`. ![Samples #center](images/samples.png "Select sample captures") -1. Double-click on the report in `Streamline Data`, then click `Analyze` when prompted. The report will be processed, and an interactive timeline will be shown. +4. Double-click on the report in `Streamline Data`, then click `Analyze` when prompted. After the report is processed, you'll see an interactive timeline. ![Timeline #center](images/timeline.png "Streamline Timeline") ## Analyze the results @@ -28,3 +27,11 @@ To help you understand the capabilities of Streamline, an example Streamline pro The charts in the `Timeline` view show the performance counter activity captured from the device. Hover over the charts to see the values at that point in time. Use the Calipers to focus on particular windows of activity. Refer to the [Streamline User Guide](https://developer.arm.com/documentation/101816/latest/Analyze-your-capture) for full instructions on how to use the features in the `Timeline` view. Understanding the output of Streamline is key to the usefulness of Streamline. [Android performance triage with Streamline](https://developer.arm.com/documentation/102540/latest/) describes how to understand the capture from a number of points of view, depending on what information you are trying to extract from it. + +## What you've accomplished and what's next + +You've now viewed an example Arm Streamline report and interpreted the results using Arm documentation. + +Next, you'll use Arm Streamline to capture data for your application. + + From 12d1bf88a87bd7595400db977e6a71d09dbe830a Mon Sep 17 00:00:00 2001 From: anupras-mohapatra-arm Date: Thu, 25 Jun 2026 13:05:54 -0500 Subject: [PATCH 04/18] moving content out of supporting tools into final page --- .../mobile-graphics-and-gaming/ams/_index.md | 2 +- .../mobile-graphics-and-gaming/ams/malioc.md | 15 +++++++++++++++ .../ams/supporting_tools.md | 4 ++-- 3 files changed, 18 insertions(+), 3 deletions(-) diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/_index.md b/content/learning-paths/mobile-graphics-and-gaming/ams/_index.md index 6a3e97f78b..3e7a59e078 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/_index.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/_index.md @@ -12,7 +12,7 @@ learning_objectives: - Generate and inspect a Performance Advisor report - Capture and analyze a frame with Frame Advisor and RenderDoc for Arm GPUs - Use Mali Offline Compiler to estimate shader cost - - Get started profiling and optimizing your application. + - Get started profiling and optimizing your application prerequisites: - An Android device. diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md b/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md index 0994ab882d..3fa91ddb32 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md @@ -144,3 +144,18 @@ You've used Mali Offline Compiler to analyze shader performance on a Mali-based You can use the components and workflows described in this Learning Path to profile your applications and analyze performance using Arm Performance Studio. +You can also explore the following supporting tools: + +- [Unity Integration package](https://github.com/ARM-software/mobile-studio-integration-for-unity/). Integrate this package in to your Unity application during development and gain the ability to add more application awareness to Performance Advisor and Streamline profiling reports. This package exports key software counters from the Unity profiler to Streamline, and also exports a C# API to allow developers to export custom annotations and software counters that can be visualized in performance reports. + +- [Unity System Metrics for Mali package](https://forum.unity.com/threads/introducing-system-metrics-mali-package.1126178/). Integrate this package in to your Unity application during development and visualize frame-based Arm GPU performance metrics using the Unity profiler. This allows efficient early triage of performance problems in-editor, allowing developers to switching to Streamline only when they need to investigate rendering performance issues in more detail. + +- [Godot integration package](https://github.com/ARM-software/arm-performance-studio-integration-for-godot). This package provides an open-source Godot game engine integration for Streamline and Performance Advisor. It contains GDScript bindings for the Streamline annotation API, allowing users to export custom software counters, and event annotations. + +- [Arm ASTC Encoder texture compressor](https://github.com/ARM-software/astc-encoder) is an open-source texture compressor for the Adaptive Scalable Texture Compression (ASTC) texture format. It supports all block sizes, all color profiles, as well as both 2D and volumetric 3D textures. The astcenc compressor can be built as either a standalone command-line application or a library that can be integrated into an existing asset creation pipeline. + +- [libGPUInfo library](https://github.com/ARM-software/libGPUInfo) is an open-source utility that can be integrated into an application to query the configuration of the Arm GPU present in the system, including the GPU model, shader core count, shader core performance characteristics, and cache size. This information can be used to adjust the application workload at runtime to match the capabilities of the device being used. + +- [libGPUCounters library](https://github.com/ARM-software/libGPUCounters) is an open-source utility that allows applications to select and sample a set of Arm GPU performance counters. This library provides access to the same counter data that can be visualized in the Streamline tool, allowing integration of Arm GPU data into custom tooling. + +- [libGPULayers library](https://github.com/ARM-software/libGPULayers) is an open-source project that provides tooling to quickly create new Vulkan layers for Android, as well as some off-the-shelf layers that can be used during development. diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/supporting_tools.md b/content/learning-paths/mobile-graphics-and-gaming/ams/supporting_tools.md index adec0314da..41ae22dd50 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/supporting_tools.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/supporting_tools.md @@ -1,4 +1,4 @@ ---- + From 8f8c35cf9cfbc8d75de0717ec8e422273173a5d4 Mon Sep 17 00:00:00 2001 From: anupras-mohapatra-arm Date: Thu, 25 Jun 2026 14:44:26 -0500 Subject: [PATCH 05/18] condensing list of tools --- .../mobile-graphics-and-gaming/ams/_index.md | 3 +-- .../mobile-graphics-and-gaming/ams/malioc.md | 20 ++++++++++--------- 2 files changed, 12 insertions(+), 11 deletions(-) diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/_index.md b/content/learning-paths/mobile-graphics-and-gaming/ams/_index.md index 3e7a59e078..5c98b3c034 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/_index.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/_index.md @@ -1,7 +1,7 @@ --- title: Profile an Android application with Arm Performance Studio -description: Learn how to use each of the tools supplied with Arm Performance Studio (formerly known as Arm Mobile Studio). +description: Learn how to profile an Android application using Arm Performance Studio (formerly known as Arm Mobile Studio). minutes_to_complete: 60 @@ -12,7 +12,6 @@ learning_objectives: - Generate and inspect a Performance Advisor report - Capture and analyze a frame with Frame Advisor and RenderDoc for Arm GPUs - Use Mali Offline Compiler to estimate shader cost - - Get started profiling and optimizing your application prerequisites: - An Android device. diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md b/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md index 3fa91ddb32..8b03118af1 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md @@ -19,9 +19,9 @@ malioc --help ``` The `--help` option returns usage instructions and the full list of available options for the malioc command. -Note -{{% notice %}} + +{{% notice Note %}} On macOS, Mali Offline Compiler might not be recognized as an application from an identified developer. To enable Mali Offline Compiler, open **System Preferences > Security & Privacy**, and select **Allow Anyway** for the `malioc` item. {{% /notice %}} @@ -45,6 +45,8 @@ You can compile OpenGL ES (`--opengles`) and Vulkan (`--vulkan`) shader programs A performance report will be generated. +If your frame analysis points to shader cost, compile one of your shaders. You can also use this sample to understand the report. + An example (`OpenGL ES`) shader is provided in the [documentation](https://developer.arm.com/documentation/102468/latest/Compile-your-shader): ```C #version 310 es @@ -146,16 +148,16 @@ You can use the components and workflows described in this Learning Path to prof You can also explore the following supporting tools: -- [Unity Integration package](https://github.com/ARM-software/mobile-studio-integration-for-unity/). Integrate this package in to your Unity application during development and gain the ability to add more application awareness to Performance Advisor and Streamline profiling reports. This package exports key software counters from the Unity profiler to Streamline, and also exports a C# API to allow developers to export custom annotations and software counters that can be visualized in performance reports. +- [Unity Integration package](https://github.com/ARM-software/mobile-studio-integration-for-unity/) to add more application awareness — in the form of custom annotations and software counters — to Performance Advisor and Streamline profiling reports. -- [Unity System Metrics for Mali package](https://forum.unity.com/threads/introducing-system-metrics-mali-package.1126178/). Integrate this package in to your Unity application during development and visualize frame-based Arm GPU performance metrics using the Unity profiler. This allows efficient early triage of performance problems in-editor, allowing developers to switching to Streamline only when they need to investigate rendering performance issues in more detail. +- [Unity System Metrics for Mali package](https://forum.unity.com/threads/introducing-system-metrics-mali-package.1126178/) to visualize frame-based Arm GPU performance metrics using the Unity profiler for efficient early triage of performance problems. -- [Godot integration package](https://github.com/ARM-software/arm-performance-studio-integration-for-godot). This package provides an open-source Godot game engine integration for Streamline and Performance Advisor. It contains GDScript bindings for the Streamline annotation API, allowing users to export custom software counters, and event annotations. +- [Godot integration package](https://github.com/ARM-software/arm-performance-studio-integration-for-godot) to export custom software counters and event annotations. -- [Arm ASTC Encoder texture compressor](https://github.com/ARM-software/astc-encoder) is an open-source texture compressor for the Adaptive Scalable Texture Compression (ASTC) texture format. It supports all block sizes, all color profiles, as well as both 2D and volumetric 3D textures. The astcenc compressor can be built as either a standalone command-line application or a library that can be integrated into an existing asset creation pipeline. +- [Arm ASTC Encoder texture compressor](https://github.com/ARM-software/astc-encoder) to compress and decompress textures using the Adaptive Scalable Texture Compression (ASTC) texture format. -- [libGPUInfo library](https://github.com/ARM-software/libGPUInfo) is an open-source utility that can be integrated into an application to query the configuration of the Arm GPU present in the system, including the GPU model, shader core count, shader core performance characteristics, and cache size. This information can be used to adjust the application workload at runtime to match the capabilities of the device being used. +- [libGPUInfo library](https://github.com/ARM-software/libGPUInfo) to query the configuration of the Arm GPU present in the system to adjust the application workload at runtime. -- [libGPUCounters library](https://github.com/ARM-software/libGPUCounters) is an open-source utility that allows applications to select and sample a set of Arm GPU performance counters. This library provides access to the same counter data that can be visualized in the Streamline tool, allowing integration of Arm GPU data into custom tooling. +- [libGPUCounters library](https://github.com/ARM-software/libGPUCounters) to select and sample a set of Arm GPU performance counters for integration of Arm GPU data into custom tooling. -- [libGPULayers library](https://github.com/ARM-software/libGPULayers) is an open-source project that provides tooling to quickly create new Vulkan layers for Android, as well as some off-the-shelf layers that can be used during development. +- [libGPULayers library](https://github.com/ARM-software/libGPULayers) to create new Vulkan layers for Android development. From 633e0f0d5acc2da76a28206f57d07b8b96862b43 Mon Sep 17 00:00:00 2001 From: anupras-mohapatra-arm Date: Thu, 25 Jun 2026 14:44:55 -0500 Subject: [PATCH 06/18] spaces between bullets --- .../learning-paths/mobile-graphics-and-gaming/ams/malioc.md | 6 ------ 1 file changed, 6 deletions(-) diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md b/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md index 8b03118af1..25a8514beb 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md @@ -149,15 +149,9 @@ You can use the components and workflows described in this Learning Path to prof You can also explore the following supporting tools: - [Unity Integration package](https://github.com/ARM-software/mobile-studio-integration-for-unity/) to add more application awareness — in the form of custom annotations and software counters — to Performance Advisor and Streamline profiling reports. - - [Unity System Metrics for Mali package](https://forum.unity.com/threads/introducing-system-metrics-mali-package.1126178/) to visualize frame-based Arm GPU performance metrics using the Unity profiler for efficient early triage of performance problems. - - [Godot integration package](https://github.com/ARM-software/arm-performance-studio-integration-for-godot) to export custom software counters and event annotations. - - [Arm ASTC Encoder texture compressor](https://github.com/ARM-software/astc-encoder) to compress and decompress textures using the Adaptive Scalable Texture Compression (ASTC) texture format. - - [libGPUInfo library](https://github.com/ARM-software/libGPUInfo) to query the configuration of the Arm GPU present in the system to adjust the application workload at runtime. - - [libGPUCounters library](https://github.com/ARM-software/libGPUCounters) to select and sample a set of Arm GPU performance counters for integration of Arm GPU data into custom tooling. - - [libGPULayers library](https://github.com/ARM-software/libGPULayers) to create new Vulkan layers for Android development. From 839f36040d05e953a01e0a436781022a5ab801c3 Mon Sep 17 00:00:00 2001 From: anupras-mohapatra-arm Date: Thu, 25 Jun 2026 14:54:02 -0500 Subject: [PATCH 07/18] removing supporting tools file in favor of shortened list at the end of final LP section --- .../mobile-graphics-and-gaming/ams/malioc.md | 2 +- .../ams/supporting_tools.md | 25 ------------------- 2 files changed, 1 insertion(+), 26 deletions(-) delete mode 100644 content/learning-paths/mobile-graphics-and-gaming/ams/supporting_tools.md diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md b/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md index 25a8514beb..de320f3e18 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md @@ -150,7 +150,7 @@ You can also explore the following supporting tools: - [Unity Integration package](https://github.com/ARM-software/mobile-studio-integration-for-unity/) to add more application awareness — in the form of custom annotations and software counters — to Performance Advisor and Streamline profiling reports. - [Unity System Metrics for Mali package](https://forum.unity.com/threads/introducing-system-metrics-mali-package.1126178/) to visualize frame-based Arm GPU performance metrics using the Unity profiler for efficient early triage of performance problems. -- [Godot integration package](https://github.com/ARM-software/arm-performance-studio-integration-for-godot) to export custom software counters and event annotations. +- [Godot integration package](https://github.com/ARM-software/arm-performance-studio-integration-for-godot) to export custom software counters and event annotations in Godot. - [Arm ASTC Encoder texture compressor](https://github.com/ARM-software/astc-encoder) to compress and decompress textures using the Adaptive Scalable Texture Compression (ASTC) texture format. - [libGPUInfo library](https://github.com/ARM-software/libGPUInfo) to query the configuration of the Arm GPU present in the system to adjust the application workload at runtime. - [libGPUCounters library](https://github.com/ARM-software/libGPUCounters) to select and sample a set of Arm GPU performance counters for integration of Arm GPU data into custom tooling. diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/supporting_tools.md b/content/learning-paths/mobile-graphics-and-gaming/ams/supporting_tools.md deleted file mode 100644 index 41ae22dd50..0000000000 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/supporting_tools.md +++ /dev/null @@ -1,25 +0,0 @@ - From a413f212c7a2d80b6b76cd6dbc30e78fab367c23 Mon Sep 17 00:00:00 2001 From: anupras-mohapatra-arm Date: Thu, 25 Jun 2026 15:42:00 -0500 Subject: [PATCH 08/18] improved alt-text --- .../mobile-graphics-and-gaming/ams/ams.md | 4 ++-- .../mobile-graphics-and-gaming/ams/fa.md | 22 +++++++++---------- .../ams/pa_example.md | 2 +- .../ams/renderdoc.md | 10 ++++----- .../ams/streamline.md | 8 +++---- .../ams/streamline_example.md | 7 +++--- 6 files changed, 26 insertions(+), 27 deletions(-) diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/ams.md b/content/learning-paths/mobile-graphics-and-gaming/ams/ams.md index fd875867b8..bcd9b063eb 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/ams.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/ams.md @@ -49,10 +49,10 @@ To open the tools, launch the Performance Studio Hub: - On Windows, search for Performance Studio. - On macOS and Linux, open the Performance Studio application file from the install directory. -![Performance Studio Hub](images/ps_hub.png) +![Screenshot of the Arm Performance Studio Hub showing launch cards for Frame Advisor, RenderDoc for Arm GPUs, Streamline, Mali Offline Compiler, and Streamline CLI#center](images/ps_hub.png) ## What you've accomplished and what's next You've now set up Arm Performance Studio and updated your PATH environment variable so you can use suite of available tools to profile applications. -Next, you'll set up the application that you'll profile in this Learning Path. \ No newline at end of file +Next, you'll set up the application that you'll profile in this Learning Path. diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/fa.md b/content/learning-paths/mobile-graphics-and-gaming/ams/fa.md index 9819a628e1..cd4852a1ba 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/fa.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/fa.md @@ -1,6 +1,6 @@ --- # User change -title: "Analyze your application with Frame Advisor" +title: Analyze your application with Frame Advisor weight: 8 # 1 is first, 2 is second, etc. @@ -18,15 +18,15 @@ Start by connecting to your device. - On Windows, search for Performance Studio. - On macOS and Linux, open the Performance Studio application file from the install directory. - ![Performance Studio Hub](images/ps_hub.png) + ![Screenshot of the Arm Performance Studio Hub showing the Frame Advisor launch card used to open Frame Advisor#center](images/ps_hub.png) 2. Select `New trace` to start a new trace. - ![Frame Advisor launch screen](images/fa_launch_screen.png) + ![Screenshot of the Frame Advisor welcome screen showing the New trace button used to start a frame capture session#center](images/fa_launch_screen.png) 3. Select your device, and the application that you want to capture frames from. - ![Device connection screen](images/fa_connect.png) + ![Screenshot of Frame Advisor showing a connected Android device, a selected debuggable application, OpenGL ES selected, and the Next button for starting the session#center](images/fa_connect.png) 4. If your application uses the Vulkan API, change the selection in the API settings to `Vulkan`. @@ -40,7 +40,7 @@ After connecting to your device, you can capture a frame burst. 1. The `Capture` screen provides options for your capture session. - ![Frame Advisor capture screen](images/fa_capture.png) + ![Screenshot of the Frame Advisor Capture frames for analysis screen showing the live application preview, frame count control, and Capture button#center](images/fa_capture.png) When you approach the part of your game where the problem occurs, click `Pause` and use the `Step` button to focus in just before it. @@ -54,27 +54,27 @@ After connecting to your device, you can capture a frame burst. Frame Advisor presents the captured data in the `Analysis` screen. See your captured frames in the `Frame Hierarchy` view. -![Example Analysis screen](images/fa_example_analysis_screen_1-1.png) +![Screenshot of the Frame Advisor Analysis screen showing Frame Hierarchy, Render Graph, API Calls, Framebuffers, Content Metrics, and Detailed Metrics panels for a captured frame#center](images/fa_example_analysis_screen_1-1.png) Explore each frame to evaluate how efficiently they were rendered on the device. 1. Look at the Render Graph to see how the frame was constructed. - ![Render Graph](images/fa_render_graph_1.1.gif) + ![Render Graph view in Frame Advisor showing render passes connected by texture and render-buffer dependencies so unused attachments can be identified#center](images/fa_render_graph_1.1.gif) Evaluate the render graph to look for render passes or input or output attachments that aren’t used in the final output, and could be removed, saving processing power and bandwidth. 1. Expand a frame in the `Frame Hierarchy` view, to see the render passes and draw calls within it. Step through the draw calls and watch the scene being built up in the `Framebuffers` view with each draw. Look for draw calls that could be eliminated, such as those that do not contribute anything to the final output. Look for identical draw calls that could be batched together into one draw. - ![Framebuffers view](images/fa_frame_buffer_view.png) + ![Framebuffers view in Frame Advisor showing the selected draw call output so you can step through how the frame is built#center](images/fa_frame_buffer_view.png) 1. In the `Content Metrics` view, sort draw calls by the number of primitives to find the most expensive objects. See whether these objects could be simplified. - ![Content Metrics view](images/fa_content_metrics.png) + ![Content Metrics view in Frame Advisor sorted by primitive count with the Prims column highlighted to identify expensive draw calls#center](images/fa_content_metrics.png) 1. For an expensive object, check the `Detailed Metrics` view to see how efficiently the object's mesh is being rendered to the screen. Look for objects with duplicated vertices, or those that do not efficiently reuse indices. - ![Detailed Metrics view](images/fa_detailed_metrics_view.png) + ![Detailed Metrics view in Frame Advisor showing mesh complexity, locality, redundancy, and memory layout for the selected draw call#center](images/fa_detailed_metrics_view.png) Watch this [video tutorial](https://developer.arm.com/Additional%20Resources/Video%20Tutorials/Capture%20and%20analyze%20a%20problem%20frame%20with%20Frame%20Advisor) to see how to capture and analyze a problem frame with Frame Advisor. @@ -82,4 +82,4 @@ Watch this [video tutorial](https://developer.arm.com/Additional%20Resources/Vid You've now analyzed your application with Frame Advisor. -Next, you'll use RenderDoc for Arm GPUs to capture frames and select application events for debugging. \ No newline at end of file +Next, you'll use RenderDoc for Arm GPUs to capture frames and select application events for debugging. diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/pa_example.md b/content/learning-paths/mobile-graphics-and-gaming/ams/pa_example.md index a48b3280f5..a7bb43da54 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/pa_example.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/pa_example.md @@ -30,7 +30,7 @@ You can use the [Arm Streamline example capture](/learning-paths/mobile-graphics Report performance_advisor-.html" successfully generated ``` Open the report in a browser and explore the report. - ![Performance Advisor #center](images/pa.png "Performance Advisor report") + ![Screenshot of a Performance Advisor report showing device information, capture summary, average frame rate, boundedness distribution, and resource utilization#center](images/pa.png "Performance Advisor report") ## Evaluate the report diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/renderdoc.md b/content/learning-paths/mobile-graphics-and-gaming/ams/renderdoc.md index 3541bbd8bb..127c862c02 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/renderdoc.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/renderdoc.md @@ -16,7 +16,7 @@ To run RenderDoc for Arm GPUs, follow these steps: 1. Open RenderDoc for Arm GPUs and select your connected device from the **Replay Context** dropdown list at the bottom left of the RenderDoc UI. - ![Replay Context dropdown location in RenderDoc](images/rd_replay_context.png) + ![Screenshot of the RenderDoc Replay Context selector at the bottom left, where you choose the connected Android target before launching the app#center](images/rd_replay_context.png) The RenderDoc APK starts running on your target. @@ -26,7 +26,7 @@ To run RenderDoc for Arm GPUs, follow these steps: 1. Click **Launch**, to start the application running on your target. After a successful launch, a new target-specific tab opens in the UI where you can select the frames that you want to capture. - ![Capture frame controls in RenderDoc](images/rd_capture_controls.png) + ![Screenshot of RenderDoc for Arm GPUs showing an established Android target connection, capture frame controls, and collected frame thumbnails#center](images/rd_capture_controls.png) As your application runs, you can choose to: @@ -40,11 +40,11 @@ To run RenderDoc for Arm GPUs, follow these steps: 1. Select a capture from the **Captures collected** window and click **Open**. When the frame has loaded, it is displayed on the target and in the **Texture Viewer** tab, and the **Event Browser** is populated. - ![A captured frame loaded into RenderDoc](images/rd_full_ui.png) + ![Screenshot of a captured frame opened in RenderDoc showing the Event Browser, Texture Viewer, API Inspector, and output preview for the selected event#center](images/rd_full_ui.png) By default, the **Event Browser** shows all `action()` events, which include draws, copies, and clears. Enter a search term in the **Filter** dropdown to filter these events. - ![Event Browser in RenderDoc](images/rd_event_browser.png) + ![Screenshot of the RenderDoc Event Browser filtered for draw events with a selected draw call highlighted for debugging frame state#center](images/rd_event_browser.png) Selected events are highlighted with a green flag. All the other windows in the UI update to display information that is specific to the selected event. You can use this to view the render state and data resources that are used by the current event, and view the GPU output that resulted from it. @@ -54,4 +54,4 @@ See the [RenderDoc documentation](https://renderdoc.org/docs/index.html#) to exp You've now run RenderDoc for Arm GPUs on your application and learned how to capture frames and select events for debugging. -Next, you'll run Mali Offline Compiler to compile shaders and generate performance reports. \ No newline at end of file +Next, you'll run Mali Offline Compiler to compile shaders and generate performance reports. diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/streamline.md b/content/learning-paths/mobile-graphics-and-gaming/ams/streamline.md index f688c34c47..9b59e04264 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/streamline.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/streamline.md @@ -17,14 +17,14 @@ Now that you have seen an [Arm Streamline example capture](/learning-paths/mobil - On Windows, search for Performance Studio. - On macOS and Linux, open the Performance Studio application file from the install directory. - ![Performance Studio Hub](images/ps_hub.png) + ![Screenshot of the Arm Performance Studio Hub showing the Streamline launch card used to open Streamline#center](images/ps_hub.png) 1. In the Streamline `Start` view, select `Android (adb)` as your device type, then select your device from the list of detected devices. This installs the `gatord` daemon and connects to the device. 1. Wait for the list of available packages to populate, then select the one you wish to profile. 1. With `Capture Arm GPU profile` selected, Streamline will detect the Arm GPU in the device, and select an appropriate counter template for it. Alternatively, to choose a different template or to build your own configuration, select `Use advanced mode` and click `Configure counters`. - ![Connect to device #center](images/start.png "Connect to the device") + ![Screenshot of the Streamline Start view with Android adb selected, a connected Samsung device selected, a debuggable application selected, and Capture Arm GPU profile enabled#center](images/start.png "Connect to the device") {{% notice Tip %}} Optionally, you can set a preferred location to store your captures using `Window` > `Preferences` > `Data Locations`. New reports will be created in the topmost folder specified. @@ -37,7 +37,7 @@ Optionally, you can set a preferred location to store your captures using `Windo 1. The application starts automatically on the device. Interact with the application as desired for the profiling run you wish to do. 1. When you have collected enough data, click `Stop capture`. -![Stop capture #center](images/stop_capture.webp "Stop Capture") +![Screenshot of Streamline during a capture with the Stop capture button highlighted and performance charts updating in the Timeline view#center](images/stop_capture.webp "Stop Capture") Streamline will stop capturing data, remove the daemon, and process the captured data. @@ -51,4 +51,4 @@ Understanding the output of Streamline is key to the usefulness of Streamline. T You've now generated and analyzed an Arm Streamline report for your application. -Next, you'll view an example Performance Advisor report. \ No newline at end of file +Next, you'll view an example Performance Advisor report. diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/streamline_example.md b/content/learning-paths/mobile-graphics-and-gaming/ams/streamline_example.md index e8703d0e5b..d48a0b2814 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/streamline_example.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/streamline_example.md @@ -14,13 +14,13 @@ To help you understand the capabilities of Streamline, an example Streamline pro 1. To open the example profile, in Streamline, select `File` > `Import`. 2. Select `Import Streamline Sample Captures` and click `Next`. - ![Import #center](images/import.png "Import Streamline Sample Captures") + ![Screenshot of the Streamline Import dialog with Import Streamline Sample Captures selected before clicking Next#center](images/import.png "Import Streamline Sample Captures") 3. Select the Android example and click `Finish`. - ![Samples #center](images/samples.png "Select sample captures") + ![Screenshot of the Import Sample Captures dialog with the Android GPU Bound Example selected before clicking Finish#center](images/samples.png "Select sample captures") 4. Double-click on the report in `Streamline Data`, then click `Analyze` when prompted. After the report is processed, you'll see an interactive timeline. -![Timeline #center](images/timeline.png "Streamline Timeline") +![Screenshot of the Streamline Timeline tab for the Android GPU Bound Example showing CPU cycles, draw calls, frame rate, Mali core cycles, and process activity#center](images/timeline.png "Streamline Timeline") ## Analyze the results @@ -34,4 +34,3 @@ You've now viewed an example Arm Streamline report and interpreted the results u Next, you'll use Arm Streamline to capture data for your application. - From 647efcad543fc2b33aa8c4a75ef7bce4e92b96e1 Mon Sep 17 00:00:00 2001 From: anupras-mohapatra-arm Date: Thu, 25 Jun 2026 16:06:33 -0500 Subject: [PATCH 09/18] update link text --- .../learning-paths/mobile-graphics-and-gaming/ams/fa.md | 8 ++++---- .../mobile-graphics-and-gaming/ams/malioc.md | 7 ++++--- .../learning-paths/mobile-graphics-and-gaming/ams/pa.md | 4 ++-- 3 files changed, 10 insertions(+), 9 deletions(-) diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/fa.md b/content/learning-paths/mobile-graphics-and-gaming/ams/fa.md index cd4852a1ba..6049c3d15e 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/fa.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/fa.md @@ -64,19 +64,19 @@ Explore each frame to evaluate how efficiently they were rendered on the device. Evaluate the render graph to look for render passes or input or output attachments that aren’t used in the final output, and could be removed, saving processing power and bandwidth. -1. Expand a frame in the `Frame Hierarchy` view, to see the render passes and draw calls within it. Step through the draw calls and watch the scene being built up in the `Framebuffers` view with each draw. Look for draw calls that could be eliminated, such as those that do not contribute anything to the final output. Look for identical draw calls that could be batched together into one draw. +2. Expand a frame in the `Frame Hierarchy` view, to see the render passes and draw calls within it. Step through the draw calls and watch the scene being built up in the `Framebuffers` view with each draw. Look for draw calls that could be eliminated, such as those that do not contribute anything to the final output. Look for identical draw calls that could be batched together into one draw. ![Framebuffers view in Frame Advisor showing the selected draw call output so you can step through how the frame is built#center](images/fa_frame_buffer_view.png) -1. In the `Content Metrics` view, sort draw calls by the number of primitives to find the most expensive objects. See whether these objects could be simplified. +3. In the `Content Metrics` view, sort draw calls by the number of primitives to find the most expensive objects. See whether these objects could be simplified. ![Content Metrics view in Frame Advisor sorted by primitive count with the Prims column highlighted to identify expensive draw calls#center](images/fa_content_metrics.png) -1. For an expensive object, check the `Detailed Metrics` view to see how efficiently the object's mesh is being rendered to the screen. Look for objects with duplicated vertices, or those that do not efficiently reuse indices. +4. For an expensive object, check the `Detailed Metrics` view to see how efficiently the object's mesh is being rendered to the screen. Look for objects with duplicated vertices, or those that do not efficiently reuse indices. ![Detailed Metrics view in Frame Advisor showing mesh complexity, locality, redundancy, and memory layout for the selected draw call#center](images/fa_detailed_metrics_view.png) -Watch this [video tutorial](https://developer.arm.com/Additional%20Resources/Video%20Tutorials/Capture%20and%20analyze%20a%20problem%20frame%20with%20Frame%20Advisor) to see how to capture and analyze a problem frame with Frame Advisor. +To see how to capture and analyze a problem frame with Frame Advisor, see the [Capture and analyze a problem frame with Frame Advisor video tutorial](https://developer.arm.com/Additional%20Resources/Video%20Tutorials/Capture%20and%20analyze%20a%20problem%20frame%20with%20Frame%20Advisor). ## What you've accomplished and what's next diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md b/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md index de320f3e18..130b1266bc 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md @@ -47,7 +47,7 @@ A performance report will be generated. If your frame analysis points to shader cost, compile one of your shaders. You can also use this sample to understand the report. -An example (`OpenGL ES`) shader is provided in the [documentation](https://developer.arm.com/documentation/102468/latest/Compile-your-shader): +An example (`OpenGL ES`) shader is provided in [Compile your shader](https://developer.arm.com/documentation/102468/latest/Compile-your-shader) in the Arm documentation: ```C #version 310 es #define WINDOW_SIZE 5 @@ -99,7 +99,8 @@ Longest path cycles: 4.53 0.00 0.25 2.50 A A = Arithmetic, LS = Load/Store, V = Varying, T = Texture ``` -An example optimization is explained in the [documentation](https://developer.arm.com/documentation/102468/latest/Optimize-your-shader). +An example optimization is described in [Optimize your shader](https://developer.arm.com/documentation/102468/latest/Optimize-your-shader) in the Arm documentation: + ```C #version 310 es #define WINDOW_SIZE 5 @@ -138,7 +139,7 @@ A = Arithmetic, LS = Load/Store, V = Varying, T = Texture ``` Observe that the number of `Arithmetic` cycles has been significantly reduced. -Understanding the output of the report is key to the usefulness of the Mali Offline Compiler. This brief [video tutorial](https://developer.arm.com/Additional%20Resources/Video%20Tutorials/Arm%20Mali%20GPU%20Training%20-%20EP3-5) is an excellent starter. +Understanding the output of the report is key to the usefulness of the Mali Offline Compiler. For more information, see the [Arm GPU Training - Episode 3.5: Mali Offline Compiler](https://developer.arm.com/Additional%20Resources/Video%20Tutorials/Arm%20Mali%20GPU%20Training%20-%20EP3-5) video tutorial. ## What you've accomplished diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/pa.md b/content/learning-paths/mobile-graphics-and-gaming/ams/pa.md index aa6ab7e1ba..e8cd84a9a0 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/pa.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/pa.md @@ -89,7 +89,7 @@ See the [Get started with Performance Advisor Tutorial](https://developer.arm.co streamline-cli -pa my_capture.apc ``` - The available options are documented in the [Performance Advisor User Guide](https://developer.arm.com/documentation/102009/latest/Command-line-options/The-pa-command), else can be seen with: + For a list of available options, see [The Streamline-cli -pa command](https://developer.arm.com/documentation/102009/9-7/Command-line-options/The-Streamline-cli--pa-command) in the Arm documentation, or run the following command: ```console streamline-cli -pa -h @@ -114,7 +114,7 @@ This feature is particularly useful when used within a [CI workflow](https://dev ## Specify performance budgets -You can specify a performance budget which will be reflected in the Performance Advisor report. For more information, refer to the [Performance Advisor User Guide](https://developer.arm.com/documentation/102009/latest/Quick-start-guide/Setting-performance-budgets) section on performance budgets. +You can specify a performance budget which will be reflected in the Performance Advisor report. For more information, see [Setting performance budgets](https://developer.arm.com/documentation/102009/latest/Quick-start-guide/Setting-performance-budgets) in the Arm documentation. ## What you've accomplished and what's next From 80dc3ae53b02d9b1c4b767b205b22cce6b5eb842 Mon Sep 17 00:00:00 2001 From: anupras-mohapatra-arm Date: Thu, 25 Jun 2026 17:37:20 -0500 Subject: [PATCH 10/18] second pass style edits --- .../mobile-graphics-and-gaming/ams/_index.md | 5 ++- .../mobile-graphics-and-gaming/ams/ams.md | 10 +++--- .../mobile-graphics-and-gaming/ams/fa.md | 32 +++++++++-------- .../mobile-graphics-and-gaming/ams/malioc.md | 24 +++++++------ .../mobile-graphics-and-gaming/ams/pa.md | 34 ++++++++++--------- .../ams/pa_example.md | 10 +++--- .../ams/renderdoc.md | 22 ++++++------ .../ams/setup_tasks.md | 20 +++++------ .../ams/streamline.md | 20 ++++++----- .../ams/streamline_example.md | 17 +++++----- 10 files changed, 103 insertions(+), 91 deletions(-) diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/_index.md b/content/learning-paths/mobile-graphics-and-gaming/ams/_index.md index 5c98b3c034..a0ef9c4dc9 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/_index.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/_index.md @@ -15,12 +15,11 @@ learning_objectives: prerequisites: - An Android device. - - Arm Performance Studio supports applications built with OpenGL ES versions 2.0 to 3.2, or Vulkan versions 1.0 to 1.2. + - An debuggable build of your application built with OpenGL ES versions 2.0 to 3.2, or Vulkan versions 1.0 to 1.2. - For OpenGL ES applications, your device must be running Android 10 or later. - For Vulkan applications, your device must be running Android 9 or later. - - A debuggable build of your application. - Arm Performance Studio installed. Follow the [Arm Performance Studio install guide](/install-guides/ams/) for instructions. - - Android SDK Platform tools installed. Required for the Android Debug bridge (adb). + - Android SDK Platform tools installed for the Android Debug bridge (adb). author: Ronan Synnott diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/ams.md b/content/learning-paths/mobile-graphics-and-gaming/ams/ams.md index bcd9b063eb..25939ddbe4 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/ams.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/ams.md @@ -9,11 +9,13 @@ layout: "learningpathall" --- ## What is Arm Performance Studio? -[Arm Performance Studio](https://developer.arm.com/Tools%20and%20Software/Arm%20Performance%20Studio) is a performance analysis tool suite for developers to performance test their applications on devices with Mali-based GPUs. It consists of four easy-to-use tools that show you how well your application performs either on off-the-shelf Android devices, or Linux targets. The tools help you to identify problems that might slow down performance, overheat the device, or drain the battery. +[Arm Performance Studio](https://developer.arm.com/Tools%20and%20Software/Arm%20Performance%20Studio) is a performance analysis tool suite that you can use to performance test applications on devices with Mali-based GPUs. + +Performance Studio consists of four tools that show you how well your application performs either on off-the-shelf Android devices, or Linux targets. You can use the tools to identify problems that might slow down performance, overheat the device, or drain the battery. | Component | Functionality | |----------|-------------| -| [Streamline](https://developer.arm.com/Tools%20and%20Software/Streamline%20Performance%20Analyzer) with [Performance Advisor](https://developer.arm.com/Tools%20and%20Software/Performance%20Advisor) | Capture a performance profile that shows all the performance counter activity from the device. Generate an easy-to-read performance summary from an annotated Streamline capture, and get actionable advice about where you should optimize. | +| [Streamline](https://developer.arm.com/Tools%20and%20Software/Streamline%20Performance%20Analyzer) with [Performance Advisor](https://developer.arm.com/Tools%20and%20Software/Performance%20Advisor) | Capture a performance profile that shows all the performance counter activity from the device. Generate a performance summary from an annotated Streamline capture, and get actionable advice about where you should optimize. | | [Frame Advisor](https://developer.arm.com/Tools%20and%20Software/Frame%20Advisor) | Capture the API calls and rendering from a problem frame and get comprehensive geometry metrics to discover what might be slowing down your application. | | [Mali Offline Compiler](https://developer.arm.com/Tools%20and%20Software/Mali%20Offline%20Compiler) | Analyze how efficiently your shader programs perform on a range of Mali GPUs. | | [RenderDoc for Arm GPUs](https://developer.arm.com/Tools%20and%20Software/RenderDoc%20for%20Arm%20GPUs) | The industry-standard tool for debugging Vulkan graphics applications, including early support for Arm GPU extensions and Android features. | @@ -26,7 +28,7 @@ For installation instructions, see the [Arm Performance Studio install guide](/i ## Update your PATH environment variable (Linux and macOS) -Edit your `PATH` environment variable to add the paths to the Streamline and Mali Offline Compiler executables. This is so that you can run Streamline's `Streamline-cli -pa` command and Mali Offline Compiler's `malioc` command from any directory. This step is not necessary on Windows, as this is done automatically when Arm Performance Studio is installed. +Edit your `PATH` environment variable to add the paths to the Streamline and Mali Offline Compiler executables. By adding the paths, you can run Streamline's `Streamline-cli -pa` command and Mali Offline Compiler's `malioc` command from any directory. This step is not necessary on Windows, as this is done automatically when Arm Performance Studio is installed. On macOS, edit your `/etc/paths` file to add the following paths: @@ -53,6 +55,6 @@ To open the tools, launch the Performance Studio Hub: ## What you've accomplished and what's next -You've now set up Arm Performance Studio and updated your PATH environment variable so you can use suite of available tools to profile applications. +You've set up Arm Performance Studio and updated your `PATH` so you can use the profiling tools from a terminal. Next, you'll set up the application that you'll profile in this Learning Path. diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/fa.md b/content/learning-paths/mobile-graphics-and-gaming/ams/fa.md index 6049c3d15e..c5891b4fd9 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/fa.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/fa.md @@ -10,7 +10,9 @@ layout: "learningpathall" ## Connect to your Android device -[Frame Advisor](https://developer.arm.com/Tools%20and%20Software/Frame%20Advisor) offers in-depth frame-based analysis for mobile graphics in Android applications. By capturing the API calls and rendering processes of a specific frame, you can identify potential performance bottlenecks that may be causing slowdowns in your application. +[Frame Advisor](https://developer.arm.com/Tools%20and%20Software/Frame%20Advisor) offers in-depth frame-based analysis for mobile graphics in Android applications. + +By capturing the API calls and rendering processes of a specific frame, you can identify performance bottlenecks that might slow down your application. Start by connecting to your device. @@ -20,7 +22,7 @@ Start by connecting to your device. ![Screenshot of the Arm Performance Studio Hub showing the Frame Advisor launch card used to open Frame Advisor#center](images/ps_hub.png) -2. Select `New trace` to start a new trace. +2. Select **New trace** to start a new trace. ![Screenshot of the Frame Advisor welcome screen showing the New trace button used to start a frame capture session#center](images/fa_launch_screen.png) @@ -28,31 +30,31 @@ Start by connecting to your device. ![Screenshot of Frame Advisor showing a connected Android device, a selected debuggable application, OpenGL ES selected, and the Next button for starting the session#center](images/fa_connect.png) -4. If your application uses the Vulkan API, change the selection in the API settings to `Vulkan`. +4. If your application uses the Vulkan API, change the selection in the API settings to **Vulkan**. -5. Click `Next` to continue. +5. Select **Next** to continue. - Unless you chose the `Pause on connect` option in the `Device connection` screen, the application starts automatically on the device. + Unless you chose the **Pause on connect** option in the **Device connection** screen, the application starts automatically on the device. ## Capture a frame burst After connecting to your device, you can capture a frame burst. -1. The `Capture` screen provides options for your capture session. +1. The **Capture** screen provides options for your capture session. ![Screenshot of the Frame Advisor Capture frames for analysis screen showing the live application preview, frame count control, and Capture button#center](images/fa_capture.png) - When you approach the part of your game where the problem occurs, click `Pause` and use the `Step` button to focus in just before it. + When you approach the part of your game where the problem occurs, select **Pause** and use the **Step** button to focus in just before it. -2. You can capture one frame burst of up to 3 consecutive frames. Adjust the `Frame count` as required. +2. You can capture one frame burst of up to three consecutive frames. Adjust the **Frame count** as required. -3. Click the `Capture` button to start capturing the frame burst. Wait for the capture to complete. This may take several seconds. +3. Select the **Capture** button to start capturing the frame burst. Wait for the capture to complete. This may take several seconds. -4. Click `Analyze` to see the results. It may take a few minutes to analyze the data. +4. Select **Analyze** to see the results. It may take a few minutes to analyze the data. ## Analyze the capture -Frame Advisor presents the captured data in the `Analysis` screen. See your captured frames in the `Frame Hierarchy` view. +Frame Advisor presents the captured data in the **Analysis** screen. See your captured frames in the **Frame Hierarchy** view. ![Screenshot of the Frame Advisor Analysis screen showing Frame Hierarchy, Render Graph, API Calls, Framebuffers, Content Metrics, and Detailed Metrics panels for a captured frame#center](images/fa_example_analysis_screen_1-1.png) @@ -62,17 +64,17 @@ Explore each frame to evaluate how efficiently they were rendered on the device. ![Render Graph view in Frame Advisor showing render passes connected by texture and render-buffer dependencies so unused attachments can be identified#center](images/fa_render_graph_1.1.gif) - Evaluate the render graph to look for render passes or input or output attachments that aren’t used in the final output, and could be removed, saving processing power and bandwidth. + Evaluate the render graph to look for render passes or input or output attachments that aren’t used in the final output and can be removed to save processing power and bandwidth. -2. Expand a frame in the `Frame Hierarchy` view, to see the render passes and draw calls within it. Step through the draw calls and watch the scene being built up in the `Framebuffers` view with each draw. Look for draw calls that could be eliminated, such as those that do not contribute anything to the final output. Look for identical draw calls that could be batched together into one draw. +2. Expand a frame in the **Frame Hierarchy** view, to see the render passes and draw calls within it. Step through the draw calls and watch the scene being built up in the **Framebuffers** view with each draw. Look for draw calls that can be eliminated, or identical draw calls that can be batched together. ![Framebuffers view in Frame Advisor showing the selected draw call output so you can step through how the frame is built#center](images/fa_frame_buffer_view.png) -3. In the `Content Metrics` view, sort draw calls by the number of primitives to find the most expensive objects. See whether these objects could be simplified. +3. In the **Content Metrics** view, sort draw calls by the number of primitives to find the most expensive objects. See whether these objects could be simplified. ![Content Metrics view in Frame Advisor sorted by primitive count with the Prims column highlighted to identify expensive draw calls#center](images/fa_content_metrics.png) -4. For an expensive object, check the `Detailed Metrics` view to see how efficiently the object's mesh is being rendered to the screen. Look for objects with duplicated vertices, or those that do not efficiently reuse indices. +4. For an expensive object, check the **Detailed Metrics** view to see how efficiently the object's mesh is being rendered to the screen. Look for objects with duplicated vertices, or those that do not efficiently reuse indices. ![Detailed Metrics view in Frame Advisor showing mesh complexity, locality, redundancy, and memory layout for the selected draw call#center](images/fa_detailed_metrics_view.png) diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md b/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md index 130b1266bc..ba627e0e65 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md @@ -1,6 +1,6 @@ --- # User change -title: Generate a performance report with Mali Offline Compiler +title: Analyze shader program performance with Mali Offline Compiler weight: 10 # 1 is first, 2 is second, etc. @@ -10,9 +10,9 @@ layout: "learningpathall" ## Before you begin -Mali Offline Compiler is a command-line tool that you can use to compile all shaders and kernels from OpenGL ES and Vulkan, and generate a performance report for the GPU of interest. +Mali Offline Compiler is a command-line tool that you can use to compile shaders and kernels from OpenGL ES and Vulkan. The tool generates a performance report for the GPU of interest. -In a terminal, test that Mali Offline Compiler is installed correctly, by typing: +To test that Mali Offline Compiler is installed correctly, run: ``` malioc --help @@ -20,7 +20,6 @@ malioc --help The `--help` option returns usage instructions and the full list of available options for the malioc command. - {{% notice Note %}} On macOS, Mali Offline Compiler might not be recognized as an application from an identified developer. To enable Mali Offline Compiler, open **System Preferences > Security & Privacy**, and select **Allow Anyway** for the `malioc` item. {{% /notice %}} @@ -41,11 +40,11 @@ malioc --info --core ## Compile your shader -You can compile OpenGL ES (`--opengles`) and Vulkan (`--vulkan`) shader programs, as well as Open GL (`--opengl `) C kernels (Linux host only). +You can compile OpenGL ES (`--opengles`) and Vulkan (`--vulkan`) shader programs. On Linux hosts, you can also compile OpenGL (`--opengl `) C kernels. A performance report will be generated. -If your frame analysis points to shader cost, compile one of your shaders. You can also use this sample to understand the report. +If your frame analysis points to shader cost, compile one of your shaders. You can also use this sample shader to learn how to read the report. An example (`OpenGL ES`) shader is provided in [Compile your shader](https://developer.arm.com/documentation/102468/latest/Compile-your-shader) in the Arm documentation: ```C @@ -80,13 +79,15 @@ Compile the shader for [Mali-G76](https://developer.arm.com/Processors/Mali-G76) malioc --core Mali-G76 shader.frag ``` -The full list of available options can be seen with: +To view the full list of available options, run: + ```console malioc --help ``` -For more information, refer to [Compiling OpenGL ES shaders](https://developer.arm.com/documentation/101863/latest/Using-Mali-Offline-Compiler/Compiling-OpenGL-ES-shaders) and [Compiling Vulkan shaders](https://developer.arm.com/documentation/101863/latest/Using-Mali-Offline-Compiler/Compiling-Vulkan-shaders) in the Mali Offline Compiler User Guide. -## Analyze the report +For more information, see [Compiling OpenGL ES shaders](https://developer.arm.com/documentation/101863/latest/Using-Mali-Offline-Compiler/Compiling-OpenGL-ES-shaders) and [Compiling Vulkan shaders](https://developer.arm.com/documentation/101863/latest/Using-Mali-Offline-Compiler/Compiling-Vulkan-shaders) in the Mali Offline Compiler User Guide. + +## Interpret the report The report will provide an approximate cycle cost breakdown for the major functional units in the design. Use this information to optimize your shader. @@ -130,6 +131,7 @@ void main() { } ``` Compiling the optimized implementation reports: + ```output A LS V T Bound Total instruction cycles: 0.96 0.00 0.25 2.50 T @@ -137,9 +139,9 @@ Shortest path cycles: 0.54 0.00 0.25 2.50 T Longest path cycles: 0.96 0.00 0.25 2.50 T A = Arithmetic, LS = Load/Store, V = Varying, T = Texture ``` -Observe that the number of `Arithmetic` cycles has been significantly reduced. +Observe that the number of total `Arithmetic` cycles has been significantly reduced from 4.53 to 0.96. -Understanding the output of the report is key to the usefulness of the Mali Offline Compiler. For more information, see the [Arm GPU Training - Episode 3.5: Mali Offline Compiler](https://developer.arm.com/Additional%20Resources/Video%20Tutorials/Arm%20Mali%20GPU%20Training%20-%20EP3-5) video tutorial. +To learn more about interpreting Mali Offline Compiler reports, see the [Arm GPU Training - Episode 3.5: Mali Offline Compiler](https://developer.arm.com/Additional%20Resources/Video%20Tutorials/Arm%20Mali%20GPU%20Training%20-%20EP3-5) video tutorial. ## What you've accomplished diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/pa.md b/content/learning-paths/mobile-graphics-and-gaming/ams/pa.md index e8cd84a9a0..ae3dcd7fe8 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/pa.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/pa.md @@ -18,11 +18,11 @@ This script does the following: * Temporarily installs a daemon application on your device, called `gatord`, which Streamline uses to collect counter data. * Temporarily installs the OpenGL ES or Vulkan layer library file on your device, which is needed to collect frame data. -* Enables you to specify options for the capture, such as whether to collect screenshots when the FPS drops below a certain threshold. +* Allows you to specify options for the capture, such as whether to collect screenshots when the FPS drops below a certain threshold. -To connect to the Android device and capture frame data, follow these steps: +To connect to the Android device and capture frame data: -1. Open a terminal or command prompt, navigate to the `Arm Performance Studio` install directory and locate the `streamline_me.py` script: +1. Open a terminal or command prompt, navigate to the Arm Performance Studio install directory and locate the `streamline_me.py` script: ```console cd /streamline/bin/android @@ -35,7 +35,7 @@ To connect to the Android device and capture frame data, follow these steps: ``` {{% notice Tip %}} -To see all available options, use `python3 streamline_me.py --help` +To see all available options, use `python3 streamline_me.py --help`. {{% /notice %}} 3. The script returns a numbered list of the Android package names for the debuggable applications that are installed on your device. Enter the number of the application you want to profile. @@ -62,28 +62,30 @@ To see all available options, use `python3 streamline_me.py --help` The script identifies the GPU in the device, installs the daemon application and layer library, then waits for you to complete the capture in Streamline. {{% notice Note %}} -Leave the terminal window open, as you need to come back to it after the capture is complete, to stop the script. When the script ends, any captured screenshots are saved to the directory you specified, and the daemon application and layer library are uninstalled from the device. Do not unplug the device until the script has ended. +Leave the terminal window open, as you need to come back to it after the capture is complete, to stop the script. + +When the script ends, any captured screenshots are saved to the directory you specified, and the daemon application and layer library are uninstalled from the device. Don't unplug the device until the script has ended. {{% /notice %}} -See the [Get started with Performance Advisor Tutorial](https://developer.arm.com/documentation/102478/latest/Run-the-streamline-me-py-script) for full instructions. +For full instructions, see the [Get started with Performance Advisor Tutorial](https://developer.arm.com/documentation/102478/latest/Run-the-streamline-me-py-script). ## Capture data with Streamline -1. Open Streamline and select the device and application on the `Start` tab. +1. Open Streamline and select the device and application on the **Start** tab. -1. Click `Start capture` to start capturing profile data from the target. Enter a name and location for the capture file that Streamline creates. +2. Select **Start capture** to start capturing profile data from the target. Enter a name and location for the capture file that Streamline creates. -1. The application starts automatically on the device. Interact with the application as required. +3. The application starts automatically on the device. Interact with the application as required. -1. When you have collected enough data, click the `Stop capture` button. +4. When you have collected enough data, select **Stop capture**. -1. Return to your terminal, and press `ENTER` to terminate the `streamline_me.py` script. +5. Return to your terminal, and press `ENTER` to terminate the `streamline_me.py` script. ## Generate an HTML performance report 1. In the terminal window, navigate to the location where you stored the Streamline capture file (`.apc`). -1. Run Streamline's `streamline-cli` command with the `-pa` option on the Streamline capture file to generate the report. The default name is `report.html`. +2. Run Streamline's `streamline-cli` command with the `-pa` option on the Streamline capture file to generate the report. The default name is `report.html`. ```console streamline-cli -pa my_capture.apc @@ -95,10 +97,10 @@ See the [Get started with Performance Advisor Tutorial](https://developer.arm.co streamline-cli -pa -h ``` - To pass a list of options in a separate file to `Streamline-cli -pa`, use: + To pass a list of options in a separate file to `streamline-cli -pa`, use: ``` - Streamline-cli -pa "@" + streamline-cli -pa "@" ``` ## Generate a JSON performance report @@ -107,7 +109,7 @@ This feature is particularly useful when used within a [CI workflow](https://dev 1. In the terminal window, navigate to the location where you stored the Streamline capture file (`.apc`). -1. Run Streamline's `streamline-cli` command with the `-pa` and `--type=json` options on the Streamline capture file to generate the report (named `report.json` in below): +2. Run Streamline's `streamline-cli` command with the `-pa` and `--type=json` options on the Streamline capture file to generate the report named `report.json`: ```console streamline-cli -pa --type=json:report.json my_capture.apc ``` @@ -118,6 +120,6 @@ You can specify a performance budget which will be reflected in the Performance ## What you've accomplished and what's next -You've now generated JSON and HTML performance Performance Advisor reports for your application. +You've now generated JSON and HTML Performance Advisor reports for your application. Next, you'll perform frame-based analysis on your application using Frame Advisor. diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/pa_example.md b/content/learning-paths/mobile-graphics-and-gaming/ams/pa_example.md index a7bb43da54..d832fa705b 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/pa_example.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/pa_example.md @@ -12,15 +12,15 @@ layout: "learningpathall" Performance Advisor creates an easy-to-read report from a Streamline capture that you can use to understand how your Android application performs on a mobile device. -You can use the [Arm Streamline example capture](/learning-paths/mobile-graphics-and-gaming/ams/streamline_example/) that comes with Arm Performance Studio to generate an example `Performance Advisor` report. +You can use the [Arm Streamline example capture](/learning-paths/mobile-graphics-and-gaming/ams/streamline_example/) that comes with Arm Performance Studio to generate an example Performance Advisor report. 1. Open a terminal, and navigate to the location of the imported capture. -1. Run the `streamline-cli` command with the `-pa` option on the Streamline capture file (.apc): +1. Run the `streamline-cli` command with the `-pa` option on the Streamline capture file (`.apc`): ```command streamline-cli -pa "Android - GPU Bound Example.apc" ``` - The capture is processed, and a `html` report generated. Warnings shown can be ignored for now: + The capture is processed, and an HTML report is generated. For now, you can ignore the warnings shown: ```output Importing capture... Fetching data... @@ -29,7 +29,7 @@ You can use the [Arm Streamline example capture](/learning-paths/mobile-graphics Generating report type html... Report performance_advisor-.html" successfully generated ``` - Open the report in a browser and explore the report. + Open the report in a browser and review the summary. ![Screenshot of a Performance Advisor report showing device information, capture summary, average frame rate, boundedness distribution, and resource utilization#center](images/pa.png "Performance Advisor report") ## Evaluate the report @@ -38,6 +38,6 @@ For a detailed explanation on how to interpret the report, see the [Example Perf ## What you've accomplished and what's next -You've now created a performance report from the example Streamline capture that's packaged with Arm Performance Studio to understand the workflow for report creation. +You've created a Performance Advisor report from the example Streamline capture and seen how the report summarizes application performance. Next, you'll create a report for your application. diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/renderdoc.md b/content/learning-paths/mobile-graphics-and-gaming/ams/renderdoc.md index 127c862c02..0d430e6646 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/renderdoc.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/renderdoc.md @@ -10,9 +10,11 @@ layout: "learningpathall" ## Run RenderDoc for Arm GPUs -[RenderDoc for Arm GPUs](https://developer.arm.com/Tools%20and%20Software/RenderDoc%20for%20Arm%20GPUs) is an Arm fork of the [RenderDoc](https://renderdoc.org/) open-source debugger. The Arm release includes support for API features and extensions that are available on the latest Arm GPUs, but not yet supported in upstream RenderDoc. Arm intends to contribute changes to the upstream project, but some Arm-specific or Android-specific features might be available only in the Arm fork. +[RenderDoc for Arm GPUs](https://developer.arm.com/Tools%20and%20Software/RenderDoc%20for%20Arm%20GPUs) is an Arm fork of the [RenderDoc](https://renderdoc.org/) open-source debugger. -To run RenderDoc for Arm GPUs, follow these steps: +The Arm release includes support for API features and extensions that are available on the latest Arm GPUs, but not yet supported in upstream RenderDoc. Arm intends to contribute changes to the upstream project, but some Arm-specific or Android-specific features might be available only in the Arm fork. + +To run RenderDoc for Arm GPUs: 1. Open RenderDoc for Arm GPUs and select your connected device from the **Replay Context** dropdown list at the bottom left of the RenderDoc UI. @@ -22,23 +24,23 @@ To run RenderDoc for Arm GPUs, follow these steps: If you don't see your device, check that your device is setup correctly as described in [Setup tasks](/learning-paths/mobile-graphics-and-gaming/ams/setup_tasks/). -1. Navigate to the **Launch Application** tab, and set the Executable Path to the application that you want to debug. Click the **Browse** button to view all of the installed application packages on the target and find the `.exe` file. +2. Navigate to the **Launch Application** tab, and set the **Executable Path** to the application that you want to debug. Select the **Browse** button to view all of the installed application packages on the target and find the `.exe` file. -1. Click **Launch**, to start the application running on your target. After a successful launch, a new target-specific tab opens in the UI where you can select the frames that you want to capture. +3. Select **Launch**, to start the application running on your target. After a successful launch, a new target-specific tab opens in the UI where you can select the frames that you want to capture. ![Screenshot of RenderDoc for Arm GPUs showing an established Android target connection, capture frame controls, and collected frame thumbnails#center](images/rd_capture_controls.png) As your application runs, you can choose to: - * Capture one or more frames immediately - * Capture one or more frames after a delay - * Capture one or more frames after a specific frame + - Capture one or more frames immediately + - Capture one or more frames after a delay + - Capture one or more frames after a specific frame Use these controls to take captures of your application as it runs on the target device. Captured frames are stored temporarily on the device. -1. When you have finished capturing the frames of interest, stop the application that you are debugging. Keep RenderDoc running though, as this is needed so that you can analyze and debug your captures. +4. When you have finished capturing the frames of interest, stop the application that you are debugging. Keep RenderDoc running so that you can analyze and debug your captures. -1. Select a capture from the **Captures collected** window and click **Open**. When the frame has loaded, it is displayed on the target and in the **Texture Viewer** tab, and the **Event Browser** is populated. +5. Select a capture from the **Captures collected** window and select **Open**. When the frame has loaded, it is displayed on the target and in the **Texture Viewer** tab, and the **Event Browser** is populated. ![Screenshot of a captured frame opened in RenderDoc showing the Event Browser, Texture Viewer, API Inspector, and output preview for the selected event#center](images/rd_full_ui.png) @@ -46,7 +48,7 @@ To run RenderDoc for Arm GPUs, follow these steps: ![Screenshot of the RenderDoc Event Browser filtered for draw events with a selected draw call highlighted for debugging frame state#center](images/rd_event_browser.png) - Selected events are highlighted with a green flag. All the other windows in the UI update to display information that is specific to the selected event. You can use this to view the render state and data resources that are used by the current event, and view the GPU output that resulted from it. + Selected events are highlighted with a green flag. The other windows in the UI update to display information for the selected event, including the render state, data resources, and GPU output. See the [RenderDoc documentation](https://renderdoc.org/docs/index.html#) to explore the full list of features. diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/setup_tasks.md b/content/learning-paths/mobile-graphics-and-gaming/ams/setup_tasks.md index 2c184c5bc2..cd98df1c93 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/setup_tasks.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/setup_tasks.md @@ -1,6 +1,6 @@ --- # User change -title: Set up the Android application +title: Set up an Android application weight: 3 # 1 is first, 2 is second, etc. @@ -11,17 +11,17 @@ layout: "learningpathall" Complete the following prerequisites: -1. Ensure you have installed [Android Debug Bridge (adb)](https://developer.android.com/studio/command-line/adb). `adb` is available with the Android SDK platform tools, which are installed as part of Android Studio. Alternatively, you can download them separately as part of the Android SDK platform tools. +1. Install [Android Debug Bridge (adb)](https://developer.android.com/studio/command-line/adb). `adb` is available with the Android SDK platform tools, which are installed as part of Android Studio. Alternatively, you can download them separately as part of the Android SDK platform tools. 2. Performance Advisor uses a Python script to connect to your device. To run this script, you'll need [Python](https://www.python.org/downloads/) 3.8 or later installed. ## Build your application -You need to compile the application with debug enabled, as well as additional options to facilitate call stack unwinding by Streamline. +Compile the application with debug enabled, as well as additional options to facilitate call stack unwinding by Streamline. -- To set [Unity](https://unity.com/) applications to be debuggable, enable [Development Build](https://docs.unity3d.com/6000.0/Documentation/Manual/android-BuildProcess.html) in `Build settings`. +- To set [Unity](https://unity.com/) applications to be debuggable, enable **[Development Build](https://docs.unity3d.com/6000.0/Documentation/Manual/android-BuildProcess.html)** in **Build settings**. - In Android Studio, use a build variant that includes `debuggable true` (`isDebuggable = true` in Kotlin scripts) in the build configuration. -- In Unreal Engine, open `Project Settings > Project > Packaging > Project`, and ensure that the `For Distribution` checkbox is not set. -- For instructions on how to complie your C++ or Java applications with the right options, see the [Target setup guide for Android](https://developer.arm.com/documentation/101813/latest/Target-Setup/Compile-your-application). +- In Unreal Engine, open **Project Settings > Project > Packaging > Project**, and ensure that the **For Distribution** checkbox is not set. +- For instructions to compile your C++ or Java applications with the right options, see the [Target setup guide for Android](https://developer.arm.com/documentation/101813/latest/Target-Setup/Compile-your-application). {{% notice Tip %}} To assist with readability and add context, you can optionally include [annotations](https://developer.arm.com/documentation/101816/latest/Annotate-your-code/Add-annotations-to-your-code) in your code, which are then displayed in Streamline. @@ -31,10 +31,10 @@ To assist with readability and add context, you can optionally include [annotati To set up your Android device, follow these steps: -1. On the device, ensure that [Developer Mode](https://developer.android.com/studio/debug/dev-options) is enabled. -2. Enable `USB Debugging` under `Settings > Developer options`. If your device asks you to authorize connection to your computer, confirm the connection. +1. On the device, ensure that **[Developer Mode](https://developer.android.com/studio/debug/dev-options)** is enabled. +2. Enable **USB Debugging** under **Settings > Developer options**. If your device asks you to authorize connection to your computer, confirm the connection. 3. Connect the device to the host through USB and approve the debug connection on the device when prompted. -4. To test the connection, run the `adb devices` command in a command terminal. If successful, this returns the ID of your device: +4. To test the connection, run the `adb devices` command in a terminal. If successful, this returns the ID of your device: ```command adb devices @@ -50,4 +50,4 @@ To set up your Android device, follow these steps: You've now set up your Android device and built the application you'll use for profiling. -Next, you'll look at an example Arm Streamline report to understand the Streamline component of Arm Performance Studio. \ No newline at end of file +Next, you'll look at an example Arm Streamline report to understand the Streamline component of Arm Performance Studio. diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/streamline.md b/content/learning-paths/mobile-graphics-and-gaming/ams/streamline.md index 9b59e04264..985b66101a 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/streamline.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/streamline.md @@ -19,33 +19,35 @@ Now that you have seen an [Arm Streamline example capture](/learning-paths/mobil ![Screenshot of the Arm Performance Studio Hub showing the Streamline launch card used to open Streamline#center](images/ps_hub.png) -1. In the Streamline `Start` view, select `Android (adb)` as your device type, then select your device from the list of detected devices. This installs the `gatord` daemon and connects to the device. +2. In the Streamline **Start** view, select **Android (adb)** as your device type, then select your device from the list of detected devices. This installs the `gatord` daemon and connects to the device. -1. Wait for the list of available packages to populate, then select the one you wish to profile. -1. With `Capture Arm GPU profile` selected, Streamline will detect the Arm GPU in the device, and select an appropriate counter template for it. Alternatively, to choose a different template or to build your own configuration, select `Use advanced mode` and click `Configure counters`. +3. Wait for the list of available packages to populate, then select the application you want to profile. +4. With **Capture Arm GPU profile** selected, Streamline detects the Arm GPU in the device, and selects an appropriate counter template for it. Alternatively, to choose a different template or to build your own configuration, select **Use advanced mode** and select **Configure counters**. ![Screenshot of the Streamline Start view with Android adb selected, a connected Samsung device selected, a debuggable application selected, and Capture Arm GPU profile enabled#center](images/start.png "Connect to the device") {{% notice Tip %}} -Optionally, you can set a preferred location to store your captures using `Window` > `Preferences` > `Data Locations`. New reports will be created in the topmost folder specified. +Optionally, you can set a preferred location to store your captures using **Window** > **Preferences** > **Data Locations**. New reports will be created in the topmost folder specified. {{% /notice %}} ## Capture data -1. Click `Start capture` to start capturing profile data from the device. Enter a name and location for the capture file. +1. Select **Start capture** to start capturing profile data from the device. Enter a name and location for the capture file. -1. The application starts automatically on the device. Interact with the application as desired for the profiling run you wish to do. +2. The application starts automatically on the device. Interact with the application as desired for the profiling run you wish to do. -1. When you have collected enough data, click `Stop capture`. +3. When you have collected enough data, select **Stop capture**. ![Screenshot of Streamline during a capture with the Stop capture button highlighted and performance charts updating in the Timeline view#center](images/stop_capture.webp "Stop Capture") Streamline will stop capturing data, remove the daemon, and process the captured data. ## Analyze the results -The charts in the `Timeline` view show the performance counter activity captured from the device. Hover over the charts to see the values at that point in time. Use the Calipers to focus on particular windows of activity. Refer to the [Streamline User Guide](https://developer.arm.com/documentation/101816/latest/Analyze-your-capture) for full instructions on how to use the features in the `Timeline` view. +The charts in the **Timeline** view show the performance counter activity captured from the device. Hover over the charts to see the values at that point in time. Use the Calipers to focus on particular windows of activity. -Understanding the output of Streamline is key to the usefulness of Streamline. The documentation for [Android performance triage with Streamline](https://developer.arm.com/documentation/102540/latest/) on Arm Developer describes how to understand the capture from a number of points of view, depending on what information you are trying to extract from it. +For instructions to use the features in the **Timeline** view, see the [Streamline User Guide](https://developer.arm.com/documentation/101816/latest/Analyze-your-capture). + +Understanding the output of Streamline is key to the usefulness of the tool. To understand how to interpret the capture from different points of view, see [Android performance triage with Streamline](https://developer.arm.com/documentation/102540/latest/). ## What you've accomplished and what's next diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/streamline_example.md b/content/learning-paths/mobile-graphics-and-gaming/ams/streamline_example.md index d48a0b2814..2f8b42860f 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/streamline_example.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/streamline_example.md @@ -10,27 +10,28 @@ layout: "learningpathall" ## View the example Arm Streamline report -To help you understand the capabilities of Streamline, an example Streamline profile is provided with Arm Performance Studio. +To understand the capabilities of Streamline, use the example Streamline profile that comes with Arm Performance Studio. -1. To open the example profile, in Streamline, select `File` > `Import`. -2. Select `Import Streamline Sample Captures` and click `Next`. +1. To open the example profile, in Streamline, select **File** > **Import**. +2. Select **Import Streamline Sample Captures** and click **Next**. ![Screenshot of the Streamline Import dialog with Import Streamline Sample Captures selected before clicking Next#center](images/import.png "Import Streamline Sample Captures") -3. Select the Android example and click `Finish`. +3. Select the Android example and click **Finish**. ![Screenshot of the Import Sample Captures dialog with the Android GPU Bound Example selected before clicking Finish#center](images/samples.png "Select sample captures") -4. Double-click on the report in `Streamline Data`, then click `Analyze` when prompted. After the report is processed, you'll see an interactive timeline. +4. Select the report in **Streamline Data**, then select **Analyze** when prompted. After the report is processed, you'll see an interactive timeline. ![Screenshot of the Streamline Timeline tab for the Android GPU Bound Example showing CPU cycles, draw calls, frame rate, Mali core cycles, and process activity#center](images/timeline.png "Streamline Timeline") ## Analyze the results -The charts in the `Timeline` view show the performance counter activity captured from the device. Hover over the charts to see the values at that point in time. Use the Calipers to focus on particular windows of activity. Refer to the [Streamline User Guide](https://developer.arm.com/documentation/101816/latest/Analyze-your-capture) for full instructions on how to use the features in the `Timeline` view. +The charts in the **Timeline** view show the performance counter activity captured from the device. Hover over the charts to see the values at that point in time. Use the Calipers to focus on particular windows of activity. -Understanding the output of Streamline is key to the usefulness of Streamline. [Android performance triage with Streamline](https://developer.arm.com/documentation/102540/latest/) describes how to understand the capture from a number of points of view, depending on what information you are trying to extract from it. +For instructions to use the features in the **Timeline** view, see the [Streamline User Guide](https://developer.arm.com/documentation/101816/latest/Analyze-your-capture). + +Understanding the output of Streamline is key to the tool's usefulness. To understand how to interpret the capture from different points of view, see [Android performance triage with Streamline](https://developer.arm.com/documentation/102540/latest/). ## What you've accomplished and what's next You've now viewed an example Arm Streamline report and interpreted the results using Arm documentation. Next, you'll use Arm Streamline to capture data for your application. - From 00d0ad3e853ffd89e9ec55001252523ced921066 Mon Sep 17 00:00:00 2001 From: anupras-mohapatra-arm Date: Thu, 25 Jun 2026 17:39:12 -0500 Subject: [PATCH 11/18] adding descriptions --- .../learning-paths/mobile-graphics-and-gaming/ams/_index.md | 3 +-- content/learning-paths/mobile-graphics-and-gaming/ams/ams.md | 2 ++ content/learning-paths/mobile-graphics-and-gaming/ams/fa.md | 2 ++ .../learning-paths/mobile-graphics-and-gaming/ams/malioc.md | 2 ++ content/learning-paths/mobile-graphics-and-gaming/ams/pa.md | 2 ++ .../mobile-graphics-and-gaming/ams/pa_example.md | 2 ++ .../learning-paths/mobile-graphics-and-gaming/ams/renderdoc.md | 2 ++ .../mobile-graphics-and-gaming/ams/setup_tasks.md | 2 ++ .../mobile-graphics-and-gaming/ams/streamline.md | 2 ++ .../mobile-graphics-and-gaming/ams/streamline_example.md | 2 ++ 10 files changed, 19 insertions(+), 2 deletions(-) diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/_index.md b/content/learning-paths/mobile-graphics-and-gaming/ams/_index.md index a0ef9c4dc9..a2460d8101 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/_index.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/_index.md @@ -1,7 +1,7 @@ --- title: Profile an Android application with Arm Performance Studio -description: Learn how to profile an Android application using Arm Performance Studio (formerly known as Arm Mobile Studio). +description: Profile a debuggable Android graphics application with Arm Performance Studio and analyze performance with Streamline, Performance Advisor, Frame Advisor, RenderDoc for Arm GPUs, and Mali Offline Compiler. minutes_to_complete: 60 @@ -88,4 +88,3 @@ weight: 1 # _index.md always has weight of 1 to order corr layout: "learningpathall" # All files under learning paths have this same wrapper learning_path_main_page: "yes" # This should be surfaced when looking for related content. Only set for _index.md of learning path content. --- - diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/ams.md b/content/learning-paths/mobile-graphics-and-gaming/ams/ams.md index 25939ddbe4..74cbdac4cd 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/ams.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/ams.md @@ -2,6 +2,8 @@ # User change title: Set up Arm Performance Studio +description: Install and launch Arm Performance Studio, update your PATH, and confirm the profiling tools are available for the Android application workflow. + weight: 2 # 1 is first, 2 is second, etc. # Do not modify these elements diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/fa.md b/content/learning-paths/mobile-graphics-and-gaming/ams/fa.md index c5891b4fd9..94e9d099a4 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/fa.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/fa.md @@ -2,6 +2,8 @@ # User change title: Analyze your application with Frame Advisor +description: Capture a frame burst with Frame Advisor and inspect render graph, framebuffer, content metrics, and detailed metrics views for bottlenecks. + weight: 8 # 1 is first, 2 is second, etc. # Do not modify these elements diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md b/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md index ba627e0e65..61648c3d17 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md @@ -2,6 +2,8 @@ # User change title: Analyze shader program performance with Mali Offline Compiler +description: Use Mali Offline Compiler to compile shader code, compare cycle estimates, and understand when shader cost affects the profiled application. + weight: 10 # 1 is first, 2 is second, etc. # Do not modify these elements diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/pa.md b/content/learning-paths/mobile-graphics-and-gaming/ams/pa.md index ae3dcd7fe8..227a3e7de3 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/pa.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/pa.md @@ -2,6 +2,8 @@ # User change title: Create a Performance Advisor report for your application +description: Run streamline_me.py, capture extra frame data with Streamline, and generate HTML and JSON Performance Advisor reports for your application. + weight: 7 # 1 is first, 2 is second, etc. # Do not modify these elements diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/pa_example.md b/content/learning-paths/mobile-graphics-and-gaming/ams/pa_example.md index d832fa705b..99a6b696da 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/pa_example.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/pa_example.md @@ -2,6 +2,8 @@ # User change title: View an example Performance Advisor report +description: Generate an example Performance Advisor report from the sample Streamline capture and review the capture summary. + weight: 6 # 1 is first, 2 is second, etc. # Do not modify these elements diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/renderdoc.md b/content/learning-paths/mobile-graphics-and-gaming/ams/renderdoc.md index 0d430e6646..0fbd498f00 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/renderdoc.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/renderdoc.md @@ -2,6 +2,8 @@ # User change title: Debug your application with RenderDoc for Arm GPUs +description: Connect RenderDoc for Arm GPUs to an Android target, capture frames, and inspect events and GPU output for debugging. + weight: 9 # 1 is first, 2 is second, etc. # Do not modify these elements diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/setup_tasks.md b/content/learning-paths/mobile-graphics-and-gaming/ams/setup_tasks.md index cd98df1c93..265eb9d2b5 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/setup_tasks.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/setup_tasks.md @@ -2,6 +2,8 @@ # User change title: Set up an Android application +description: Prepare a debuggable Android application and device connection so Arm Performance Studio can capture profiling data. + weight: 3 # 1 is first, 2 is second, etc. # Do not modify these elements diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/streamline.md b/content/learning-paths/mobile-graphics-and-gaming/ams/streamline.md index 985b66101a..2225ff88af 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/streamline.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/streamline.md @@ -2,6 +2,8 @@ # User change title: Use Arm Streamline to capture data for your application +description: Capture a Streamline profile from your Android application and inspect timeline counters to start performance analysis. + weight: 5 # 1 is first, 2 is second, etc. # Do not modify these elements diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/streamline_example.md b/content/learning-paths/mobile-graphics-and-gaming/ams/streamline_example.md index 2f8b42860f..f4c3283e07 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/streamline_example.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/streamline_example.md @@ -2,6 +2,8 @@ # User change title: Interpret an example Arm Streamline report +description: Import and inspect the sample Streamline capture included with Arm Performance Studio so you can recognize key timeline views before profiling your app. + weight: 4 # 1 is first, 2 is second, etc. # Do not modify these elements From 0062caed005cdf27cca719275c9e72f5639a20f0 Mon Sep 17 00:00:00 2001 From: anupras-mohapatra-arm Date: Fri, 26 Jun 2026 10:00:48 -0500 Subject: [PATCH 12/18] nit --- .../openadkit2_safetyisolation/_index.md | 57 ++++++++++++++++++- .../mobile-graphics-and-gaming/ams/malioc.md | 2 - .../rafay-eks/nginx.md | 29 +++++----- 3 files changed, 69 insertions(+), 19 deletions(-) diff --git a/content/learning-paths/automotive/openadkit2_safetyisolation/_index.md b/content/learning-paths/automotive/openadkit2_safetyisolation/_index.md index 0bbae6a5c4..20f4c62c06 100644 --- a/content/learning-paths/automotive/openadkit2_safetyisolation/_index.md +++ b/content/learning-paths/automotive/openadkit2_safetyisolation/_index.md @@ -16,11 +16,66 @@ prerequisites: - Completion of the [Deploy Open AD Kit containerized autonomous driving simulation on Arm Neoverse](/learning-paths/automotive/openadkit1_container/) Learning Path - Basic familiarity with Docker +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-06-24T15:35:59Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: 92a6dac2b1674a44cd623a0c8c3189b38438124a6067ed7ca776999ff1d8b5bf + summary_generated_at: '2026-06-24T15:35:59Z' + summary_source_hash: 92a6dac2b1674a44cd623a0c8c3189b38438124a6067ed7ca776999ff1d8b5bf + faq_generated_at: '2026-06-24T15:35:59Z' + faq_source_hash: 92a6dac2b1674a44cd623a0c8c3189b38438124a6067ed7ca776999ff1d8b5bf + summary: >- + In this Learning Path, you'll prototype safety‑critical isolation for autonomous + driving workloads on Arm Neoverse by applying functional safety concepts, ISO 26262 and ASIL + guidance, and a safety-island architecture. You'll separate safety-critical control + logic from non-safety functions, then connect components using a publish‑subscribe model (DDS/ROS + 2) within containerized deployments or across Arm‑based instances. You'll learn about lifecycle + practices aligned with the V‑model, including clear requirements, version control, impact + analysis, and regression testing. By the end, you'll organize simulation components into + isolated units with defined interfaces and documentation suitable for advancing ISO 26262-oriented + development on Arm Neoverse. + faqs: + - question: How do I decide which components belong on the safety island versus the general + ECU? + answer: >- + Place time‑critical, safety‑relevant control logic (for example, braking or steering) on + the safety island, and keep non‑critical features (such as infotainment) on the general + ECU. The goal is strong isolation, determinism, and minimized coupling for safety‑critical + paths. + - question: What should I verify to confirm the isolation boundaries are defined correctly? + answer: >- + Check that safety‑critical components run independently from non‑critical services and communicate + only through defined publish‑subscribe interfaces. Ensure data exchanged is minimal and + purpose‑specific so that safety logic is not impacted by unrelated functions. + - question: How do ISO 26262 ASIL levels influence my development workflow in this prototype? + answer: >- + Higher ASIL targets require more rigorous processes and evidence across the V‑model. For + example, ASIL‑D changes go through full impact analysis and regression testing to prevent + introducing new risks. + - question: Should I separate components using containers on one host or across multiple Arm + Neoverse instances? + answer: >- + Both approaches support prototyping: containers model software isolation on one system, + while multiple instances model stronger physical separation. Choose the option that best + matches the isolation assumptions you want to evaluate. + - question: What artifacts should I capture to support ISO 26262 traceability in this prototype? + answer: >- + Maintain clear safety requirements, rationale for the safety‑island split, defined DDS/ROS + 2 interfaces, and mapped tests to requirements. Record versioned changes, impact analyses, + and verification results aligned to the V‑model stages. +# END generated_summary_faq + author: - Odin Shen - Julien Jayat -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md b/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md index 61648c3d17..d098056e7a 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md @@ -26,8 +26,6 @@ The `--help` option returns usage instructions and the full list of available op On macOS, Mali Offline Compiler might not be recognized as an application from an identified developer. To enable Mali Offline Compiler, open **System Preferences > Security & Privacy**, and select **Allow Anyway** for the `malioc` item. {{% /notice %}} -## Supported GPUs - To see the full list of [supported GPUs](https://developer.arm.com/documentation/101863/latest/Platform-support/GPU-support) use: ```console diff --git a/content/learning-paths/servers-and-cloud-computing/rafay-eks/nginx.md b/content/learning-paths/servers-and-cloud-computing/rafay-eks/nginx.md index 6f1c2cbba1..99576ed52c 100644 --- a/content/learning-paths/servers-and-cloud-computing/rafay-eks/nginx.md +++ b/content/learning-paths/servers-and-cloud-computing/rafay-eks/nginx.md @@ -1,16 +1,15 @@ --- -title: "Deploy NGINX and clean up" +title: Deploy NGINX to the Amazon EKS cluster and clean up +description: Deploy NGINX to an Amazon EKS cluster on AWS Graviton-based nodes, test in-cluster connectivity, and clean up the Kubernetes and cloud resources. weight: 4 ### FIXED, DO NOT MODIFY layout: learningpathall --- -With the cluster running, you can now validate it by deploying a workload. In this section, you deploy NGINX using a manifest that pins pods to `arm64` nodes, verify the pod reaches a `Running` state, and test connectivity from inside the cluster. You then clean up all provisioned resources. +## Deploy NGINX -## Deploy NGINX - -With the EKS cluster running on Graviton nodes, deploy NGINX to confirm that arm64 workloads schedule and run correctly. +With the Amazon EKS cluster running on Graviton-based nodes, deploy NGINX to confirm that `arm64` workloads schedule and run correctly. Create a file named `nginx-graviton.yaml` with the following content: @@ -104,7 +103,9 @@ nginx-arm-svc ClusterIP 10.100.42.137 80/TCP 30s ## Test NGINX connectivity -The NGINX service is type `ClusterIP`, which means it has no external IP and is only reachable from within the cluster network. The cluster also has `publicAccess: false`, so there is no public Kubernetes API endpoint. Both constraints mean you cannot test connectivity from your laptop directly. Instead, run a one-off pod inside the cluster that sends a request to the service and then deletes itself: +The NGINX service is type `ClusterIP`, which means it has no external IP and is reachable only from within the cluster network. The cluster also has `publicAccess: false`, so there's no public Kubernetes API endpoint. Both constraints mean you can't test connectivity from your local machine directly. + +Instead, run a one-off pod inside the cluster that sends a request to the service and then deletes itself: ```console kubectl run curl-test --rm -it --image=curlimages/curl --restart=Never -- curl http://nginx-arm-svc.nginx.svc @@ -127,9 +128,9 @@ working. Further configuration is required.

pod "curl-test" deleted ``` -The NGINX welcome page confirms that the workload is running and reachable on your Graviton-backed EKS cluster. +The NGINX welcome page confirms that the workload is running and reachable on your Graviton-based EKS cluster. -## Clean up +## Clean up resources Remove the NGINX workload and then delete the cluster to avoid ongoing AWS charges. @@ -148,7 +149,7 @@ service "nginx-arm-svc" deleted ``` {{< notice warning >}} -Deleting the cluster through RCTL triggers the removal of the EKS control plane, managed node group, and associated CloudFormation stacks in your AWS account. If you do not run this command, AWS will continue to charge you for the running EC2 instances and EKS control plane. +Deleting the cluster through RCTL triggers the removal of the EKS control plane, managed node group, and associated CloudFormation stacks in your AWS account. If you don't run this command, AWS will continue to charge you for the running EC2 instances and EKS control plane. {{< /notice >}} Delete the EKS cluster through Rafay: @@ -157,13 +158,9 @@ Delete the EKS cluster through Rafay: rctl delete cluster demo-eks-graviton ``` -## Summary +## What you've accomplished -In this Learning Path you: +You've now deployed NGINX using a manifest that pins pods to `arm64` nodes, verified the pod reaches a `Running` state, and tested connectivity from inside the cluster. You then cleaned up all provisioned resources. -- Connected your AWS account to the Rafay platform using a cross-account IAM role and cloud credential. -- Provisioned a private Amazon EKS cluster with a Graviton (`m7g.large`) node group using a declarative Rafay manifest and `rctl`. -- Deployed NGINX with a `nodeSelector` that pins workloads to `arm64` nodes, confirming that Arm-native containers schedule and run correctly. -- Tested in-cluster connectivity using a one-off curl pod, and cleaned up all AWS and Rafay resources. +Rafay's control plane handles cluster access without requiring a public Kubernetes API endpoint, so you can use Rafay to run private, Graviton-based EKS clusters at scale. -Rafay's control plane handles cluster access without requiring a public Kubernetes API endpoint, making it straightforward to run private, Graviton-backed EKS clusters at scale. From 883f3a7bad2e80695be397409e8080efea9fd688 Mon Sep 17 00:00:00 2001 From: anupras-mohapatra-arm Date: Fri, 26 Jun 2026 10:26:02 -0500 Subject: [PATCH 13/18] nits --- .../learning-paths/mobile-graphics-and-gaming/ams/ams.md | 9 --------- .../mobile-graphics-and-gaming/ams/malioc.md | 4 ++-- .../mobile-graphics-and-gaming/ams/setup_tasks.md | 2 +- 3 files changed, 3 insertions(+), 12 deletions(-) diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/ams.md b/content/learning-paths/mobile-graphics-and-gaming/ams/ams.md index 74cbdac4cd..1098339f8a 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/ams.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/ams.md @@ -46,15 +46,6 @@ On Linux, edit your `PATH` environment variable to add the paths to the Performa PATH=$PATH://mali_offline_compiler ``` -## Launch the tools - -To open the tools, launch the Performance Studio Hub: - -- On Windows, search for Performance Studio. -- On macOS and Linux, open the Performance Studio application file from the install directory. - -![Screenshot of the Arm Performance Studio Hub showing launch cards for Frame Advisor, RenderDoc for Arm GPUs, Streamline, Mali Offline Compiler, and Streamline CLI#center](images/ps_hub.png) - ## What you've accomplished and what's next You've set up Arm Performance Studio and updated your `PATH` so you can use the profiling tools from a terminal. diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md b/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md index d098056e7a..a8aa7e34ff 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md @@ -26,13 +26,13 @@ The `--help` option returns usage instructions and the full list of available op On macOS, Mali Offline Compiler might not be recognized as an application from an identified developer. To enable Mali Offline Compiler, open **System Preferences > Security & Privacy**, and select **Allow Anyway** for the `malioc` item. {{% /notice %}} -To see the full list of [supported GPUs](https://developer.arm.com/documentation/101863/latest/Platform-support/GPU-support) use: +To see the full list of [supported GPUs](https://developer.arm.com/documentation/101863/latest/Platform-support/GPU-support), use: ```console malioc --list ``` -To get information on [API support](https://developer.arm.com/documentation/101863/latest/Platform-support/API-support) for a given GPU, use: +For more information about [API support](https://developer.arm.com/documentation/101863/latest/Platform-support/API-support) for a given GPU, use: ```console malioc --info --core diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/setup_tasks.md b/content/learning-paths/mobile-graphics-and-gaming/ams/setup_tasks.md index 265eb9d2b5..785b83e513 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/setup_tasks.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/setup_tasks.md @@ -13,7 +13,7 @@ layout: "learningpathall" Complete the following prerequisites: -1. Install [Android Debug Bridge (adb)](https://developer.android.com/studio/command-line/adb). `adb` is available with the Android SDK platform tools, which are installed as part of Android Studio. Alternatively, you can download them separately as part of the Android SDK platform tools. +1. Install [Android Debug Bridge (adb)](https://developer.android.com/studio/command-line/adb). `adb` is available with the Android SDK platform tools, which are installed as part of Android Studio. 2. Performance Advisor uses a Python script to connect to your device. To run this script, you'll need [Python](https://www.python.org/downloads/) 3.8 or later installed. ## Build your application From 2ff8930419e421b58ea0a866dddb95a075485d63 Mon Sep 17 00:00:00 2001 From: anupras-mohapatra-arm Date: Fri, 26 Jun 2026 10:34:21 -0500 Subject: [PATCH 14/18] adding rule about lead-ins --- .github/skills/writing-style-review/SKILL.md | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/skills/writing-style-review/SKILL.md b/.github/skills/writing-style-review/SKILL.md index cf631a0227..9666f1e3fe 100644 --- a/.github/skills/writing-style-review/SKILL.md +++ b/.github/skills/writing-style-review/SKILL.md @@ -40,6 +40,7 @@ Use this skill for granular prose, voice, readability, terminology, and style re - Use plain English and avoid jargon overload. - Define acronyms on first use. - Use parallel structure in lists. +- Avoid starting sentences with "In this Learning Path"/ "In this section"/"On this page" / "In this step". - Flag sections over 700 words and suggest natural split points. - Identify paragraphs with sentences averaging over 20 words. - Note sections that introduce more than two new concepts. From a85438740506ef36b7dfe5bf0c2ed6a24ddcda50 Mon Sep 17 00:00:00 2001 From: anupras-mohapatra-arm Date: Fri, 26 Jun 2026 10:59:57 -0500 Subject: [PATCH 15/18] contractions and style updates --- .../mobile-graphics-and-gaming/ams/ams.md | 2 +- .../mobile-graphics-and-gaming/ams/fa.md | 2 +- .../mobile-graphics-and-gaming/ams/malioc.md | 4 ++-- .../mobile-graphics-and-gaming/ams/pa.md | 6 +++--- .../mobile-graphics-and-gaming/ams/renderdoc.md | 6 +++--- .../mobile-graphics-and-gaming/ams/setup_tasks.md | 4 ++-- .../mobile-graphics-and-gaming/ams/streamline.md | 10 +++++----- 7 files changed, 17 insertions(+), 17 deletions(-) diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/ams.md b/content/learning-paths/mobile-graphics-and-gaming/ams/ams.md index 1098339f8a..b437777634 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/ams.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/ams.md @@ -30,7 +30,7 @@ For installation instructions, see the [Arm Performance Studio install guide](/i ## Update your PATH environment variable (Linux and macOS) -Edit your `PATH` environment variable to add the paths to the Streamline and Mali Offline Compiler executables. By adding the paths, you can run Streamline's `Streamline-cli -pa` command and Mali Offline Compiler's `malioc` command from any directory. This step is not necessary on Windows, as this is done automatically when Arm Performance Studio is installed. +Edit your `PATH` environment variable to add the paths to the Streamline and Mali Offline Compiler executables. By adding the paths, you can run Streamline's `Streamline-cli -pa` command and Mali Offline Compiler's `malioc` command from any directory. This step isn't necessary on Windows, as this is done automatically when Arm Performance Studio is installed. On macOS, edit your `/etc/paths` file to add the following paths: diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/fa.md b/content/learning-paths/mobile-graphics-and-gaming/ams/fa.md index 94e9d099a4..640a34a2df 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/fa.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/fa.md @@ -76,7 +76,7 @@ Explore each frame to evaluate how efficiently they were rendered on the device. ![Content Metrics view in Frame Advisor sorted by primitive count with the Prims column highlighted to identify expensive draw calls#center](images/fa_content_metrics.png) -4. For an expensive object, check the **Detailed Metrics** view to see how efficiently the object's mesh is being rendered to the screen. Look for objects with duplicated vertices, or those that do not efficiently reuse indices. +4. For an expensive object, check the **Detailed Metrics** view to see how efficiently the object's mesh is being rendered to the screen. Look for objects with duplicated vertices, or those that don't efficiently reuse indices. ![Detailed Metrics view in Frame Advisor showing mesh complexity, locality, redundancy, and memory layout for the selected draw call#center](images/fa_detailed_metrics_view.png) diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md b/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md index a8aa7e34ff..2f827cf70a 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md @@ -42,7 +42,7 @@ malioc --info --core You can compile OpenGL ES (`--opengles`) and Vulkan (`--vulkan`) shader programs. On Linux hosts, you can also compile OpenGL (`--opengl `) C kernels. -A performance report will be generated. +Mali Offline Compiler generates a performance report. If your frame analysis points to shader cost, compile one of your shaders. You can also use this sample shader to learn how to read the report. @@ -89,7 +89,7 @@ For more information, see [Compiling OpenGL ES shaders](https://developer.arm.co ## Interpret the report -The report will provide an approximate cycle cost breakdown for the major functional units in the design. Use this information to optimize your shader. +The report provides an approximate cycle cost breakdown for the major functional units in the design. Use this information to optimize your shader. For example, compiling the unoptimized implementation for `Mali-G76` reports the following cycle information: ```output diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/pa.md b/content/learning-paths/mobile-graphics-and-gaming/ams/pa.md index 227a3e7de3..b231a8c712 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/pa.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/pa.md @@ -12,7 +12,7 @@ layout: "learningpathall" ## Connect to Android device and collect frame data -Now that you have seen a [Performance Advisor example report](/learning-paths/mobile-graphics-and-gaming/ams/pa_example/), you can use it to capture data from your own application. +Now that you've seen a [Performance Advisor example report](/learning-paths/mobile-graphics-and-gaming/ams/pa_example/), you can use it to capture data from your own application. Performance Advisor runs on a Streamline capture file, so the first step is to take a capture with Streamline. Streamline must capture extra frame data from the device, which Performance Advisor needs to generate a report. To capture the extra frame data, you must first run the provided Python script, `streamline_me.py`. @@ -79,7 +79,7 @@ For full instructions, see the [Get started with Performance Advisor Tutorial](h 3. The application starts automatically on the device. Interact with the application as required. -4. When you have collected enough data, select **Stop capture**. +4. When you've collected enough data, select **Stop capture**. 5. Return to your terminal, and press `ENTER` to terminate the `streamline_me.py` script. @@ -118,7 +118,7 @@ This feature is particularly useful when used within a [CI workflow](https://dev ## Specify performance budgets -You can specify a performance budget which will be reflected in the Performance Advisor report. For more information, see [Setting performance budgets](https://developer.arm.com/documentation/102009/latest/Quick-start-guide/Setting-performance-budgets) in the Arm documentation. +You can specify a performance budget that is reflected in the Performance Advisor report. For more information, see [Setting performance budgets](https://developer.arm.com/documentation/102009/latest/Quick-start-guide/Setting-performance-budgets) in the Arm documentation. ## What you've accomplished and what's next diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/renderdoc.md b/content/learning-paths/mobile-graphics-and-gaming/ams/renderdoc.md index 0fbd498f00..8848d3cfae 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/renderdoc.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/renderdoc.md @@ -24,7 +24,7 @@ To run RenderDoc for Arm GPUs: The RenderDoc APK starts running on your target. - If you don't see your device, check that your device is setup correctly as described in [Setup tasks](/learning-paths/mobile-graphics-and-gaming/ams/setup_tasks/). + If you don't see your device, check that your device is set up correctly as described in [Setup tasks](/learning-paths/mobile-graphics-and-gaming/ams/setup_tasks/). 2. Navigate to the **Launch Application** tab, and set the **Executable Path** to the application that you want to debug. Select the **Browse** button to view all of the installed application packages on the target and find the `.exe` file. @@ -40,9 +40,9 @@ To run RenderDoc for Arm GPUs: Use these controls to take captures of your application as it runs on the target device. Captured frames are stored temporarily on the device. -4. When you have finished capturing the frames of interest, stop the application that you are debugging. Keep RenderDoc running so that you can analyze and debug your captures. +4. When you've finished capturing the frames of interest, stop the application that you are debugging. Keep RenderDoc running so that you can analyze and debug your captures. -5. Select a capture from the **Captures collected** window and select **Open**. When the frame has loaded, it is displayed on the target and in the **Texture Viewer** tab, and the **Event Browser** is populated. +5. Select a capture from the **Captures collected** window and select **Open**. When the frame has loaded, it's displayed on the target and in the **Texture Viewer** tab, and the **Event Browser** is populated. ![Screenshot of a captured frame opened in RenderDoc showing the Event Browser, Texture Viewer, API Inspector, and output preview for the selected event#center](images/rd_full_ui.png) diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/setup_tasks.md b/content/learning-paths/mobile-graphics-and-gaming/ams/setup_tasks.md index 785b83e513..09b579b4cb 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/setup_tasks.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/setup_tasks.md @@ -1,6 +1,6 @@ --- # User change -title: Set up an Android application +title: Set up an Android application for profiling description: Prepare a debuggable Android application and device connection so Arm Performance Studio can capture profiling data. @@ -22,7 +22,7 @@ Compile the application with debug enabled, as well as additional options to fac - To set [Unity](https://unity.com/) applications to be debuggable, enable **[Development Build](https://docs.unity3d.com/6000.0/Documentation/Manual/android-BuildProcess.html)** in **Build settings**. - In Android Studio, use a build variant that includes `debuggable true` (`isDebuggable = true` in Kotlin scripts) in the build configuration. -- In Unreal Engine, open **Project Settings > Project > Packaging > Project**, and ensure that the **For Distribution** checkbox is not set. +- In Unreal Engine, open **Project Settings > Project > Packaging > Project**, and ensure that the **For Distribution** checkbox isn't set. - For instructions to compile your C++ or Java applications with the right options, see the [Target setup guide for Android](https://developer.arm.com/documentation/101813/latest/Target-Setup/Compile-your-application). {{% notice Tip %}} diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/streamline.md b/content/learning-paths/mobile-graphics-and-gaming/ams/streamline.md index 2225ff88af..888128304d 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/streamline.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/streamline.md @@ -12,7 +12,7 @@ layout: "learningpathall" ## Select the device and application in Streamline -Now that you have seen an [Arm Streamline example capture](/learning-paths/mobile-graphics-and-gaming/ams/streamline_example/), you can use it to capture data from your own application. +Now that you've seen an [Arm Streamline example capture](/learning-paths/mobile-graphics-and-gaming/ams/streamline_example/), you can use it to capture data from your own application. 1. Launch the Performance Studio Hub and open Streamline. @@ -29,19 +29,19 @@ Now that you have seen an [Arm Streamline example capture](/learning-paths/mobil ![Screenshot of the Streamline Start view with Android adb selected, a connected Samsung device selected, a debuggable application selected, and Capture Arm GPU profile enabled#center](images/start.png "Connect to the device") {{% notice Tip %}} -Optionally, you can set a preferred location to store your captures using **Window** > **Preferences** > **Data Locations**. New reports will be created in the topmost folder specified. +Optionally, you can set a preferred location to store your captures using **Window** > **Preferences** > **Data Locations**. New reports are created in the topmost folder specified. {{% /notice %}} ## Capture data 1. Select **Start capture** to start capturing profile data from the device. Enter a name and location for the capture file. -2. The application starts automatically on the device. Interact with the application as desired for the profiling run you wish to do. +2. The application starts automatically on the device. Interact with the application as desired for the profiling run you want to do. -3. When you have collected enough data, select **Stop capture**. +3. When you've collected enough data, select **Stop capture**. ![Screenshot of Streamline during a capture with the Stop capture button highlighted and performance charts updating in the Timeline view#center](images/stop_capture.webp "Stop Capture") -Streamline will stop capturing data, remove the daemon, and process the captured data. +Streamline stops capturing data, removes the daemon, and processes the captured data. ## Analyze the results From 958e384dd05e433f12aa1f229fc2f053a657da76 Mon Sep 17 00:00:00 2001 From: anupras-mohapatra-arm Date: Fri, 26 Jun 2026 11:35:02 -0500 Subject: [PATCH 16/18] edits --- content/learning-paths/mobile-graphics-and-gaming/ams/fa.md | 6 +++--- .../learning-paths/mobile-graphics-and-gaming/ams/malioc.md | 4 ++-- content/learning-paths/mobile-graphics-and-gaming/ams/pa.md | 6 +++--- .../mobile-graphics-and-gaming/ams/renderdoc.md | 4 ++-- .../mobile-graphics-and-gaming/ams/streamline.md | 2 +- 5 files changed, 11 insertions(+), 11 deletions(-) diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/fa.md b/content/learning-paths/mobile-graphics-and-gaming/ams/fa.md index 640a34a2df..ce1c6ca5d6 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/fa.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/fa.md @@ -50,9 +50,9 @@ After connecting to your device, you can capture a frame burst. 2. You can capture one frame burst of up to three consecutive frames. Adjust the **Frame count** as required. -3. Select the **Capture** button to start capturing the frame burst. Wait for the capture to complete. This may take several seconds. +3. Select the **Capture** button to start capturing the frame burst. Wait for the capture to complete. This might take several seconds. -4. Select **Analyze** to see the results. It may take a few minutes to analyze the data. +4. Select **Analyze** to see the results. It might take a few minutes to analyze the data. ## Analyze the capture @@ -72,7 +72,7 @@ Explore each frame to evaluate how efficiently they were rendered on the device. ![Framebuffers view in Frame Advisor showing the selected draw call output so you can step through how the frame is built#center](images/fa_frame_buffer_view.png) -3. In the **Content Metrics** view, sort draw calls by the number of primitives to find the most expensive objects. See whether these objects could be simplified. +3. In the **Content Metrics** view, sort draw calls by the number of primitives to find the most expensive objects. See whether these objects can be simplified. ![Content Metrics view in Frame Advisor sorted by primitive count with the Prims column highlighted to identify expensive draw calls#center](images/fa_content_metrics.png) diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md b/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md index 2f827cf70a..1aa8648390 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/malioc.md @@ -46,7 +46,7 @@ Mali Offline Compiler generates a performance report. If your frame analysis points to shader cost, compile one of your shaders. You can also use this sample shader to learn how to read the report. -An example (`OpenGL ES`) shader is provided in [Compile your shader](https://developer.arm.com/documentation/102468/latest/Compile-your-shader) in the Arm documentation: +The following example (`OpenGL ES`) shader is provided in [Compile your shader](https://developer.arm.com/documentation/102468/latest/Compile-your-shader) in Arm documentation: ```C #version 310 es #define WINDOW_SIZE 5 @@ -100,7 +100,7 @@ Longest path cycles: 4.53 0.00 0.25 2.50 A A = Arithmetic, LS = Load/Store, V = Varying, T = Texture ``` -An example optimization is described in [Optimize your shader](https://developer.arm.com/documentation/102468/latest/Optimize-your-shader) in the Arm documentation: +An example optimization is described in [Optimize your shader](https://developer.arm.com/documentation/102468/latest/Optimize-your-shader) in Arm documentation: ```C #version 310 es diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/pa.md b/content/learning-paths/mobile-graphics-and-gaming/ams/pa.md index b231a8c712..d90c7ba538 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/pa.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/pa.md @@ -93,7 +93,7 @@ For full instructions, see the [Get started with Performance Advisor Tutorial](h streamline-cli -pa my_capture.apc ``` - For a list of available options, see [The Streamline-cli -pa command](https://developer.arm.com/documentation/102009/9-7/Command-line-options/The-Streamline-cli--pa-command) in the Arm documentation, or run the following command: + For a list of available options, see [The Streamline-cli -pa command](https://developer.arm.com/documentation/102009/9-7/Command-line-options/The-Streamline-cli--pa-command) in Arm documentation, or run the following command: ```console streamline-cli -pa -h @@ -118,10 +118,10 @@ This feature is particularly useful when used within a [CI workflow](https://dev ## Specify performance budgets -You can specify a performance budget that is reflected in the Performance Advisor report. For more information, see [Setting performance budgets](https://developer.arm.com/documentation/102009/latest/Quick-start-guide/Setting-performance-budgets) in the Arm documentation. +You can specify a performance budget that is reflected in the Performance Advisor report. For more information, see [Setting performance budgets](https://developer.arm.com/documentation/102009/latest/Quick-start-guide/Setting-performance-budgets) in Arm documentation. ## What you've accomplished and what's next You've now generated JSON and HTML Performance Advisor reports for your application. -Next, you'll perform frame-based analysis on your application using Frame Advisor. +Next, you'll perform frame-based analysis on your application using Frame Advisor. \ No newline at end of file diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/renderdoc.md b/content/learning-paths/mobile-graphics-and-gaming/ams/renderdoc.md index 8848d3cfae..fd429c3f20 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/renderdoc.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/renderdoc.md @@ -12,7 +12,7 @@ layout: "learningpathall" ## Run RenderDoc for Arm GPUs -[RenderDoc for Arm GPUs](https://developer.arm.com/Tools%20and%20Software/RenderDoc%20for%20Arm%20GPUs) is an Arm fork of the [RenderDoc](https://renderdoc.org/) open-source debugger. +[RenderDoc for Arm GPUs](https://developer.arm.com/Tools%20and%20Software/RenderDoc%20for%20Arm%20GPUs) is an Arm fork of the [RenderDoc](https://renderdoc.org/) open-source debugger. The Arm release includes support for API features and extensions that are available on the latest Arm GPUs, but not yet supported in upstream RenderDoc. Arm intends to contribute changes to the upstream project, but some Arm-specific or Android-specific features might be available only in the Arm fork. @@ -52,7 +52,7 @@ To run RenderDoc for Arm GPUs: Selected events are highlighted with a green flag. The other windows in the UI update to display information for the selected event, including the render state, data resources, and GPU output. -See the [RenderDoc documentation](https://renderdoc.org/docs/index.html#) to explore the full list of features. +For a full list of features, see the [RenderDoc documentation](https://renderdoc.org/docs/index.html#). ## What you've accomplished and what's next diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/streamline.md b/content/learning-paths/mobile-graphics-and-gaming/ams/streamline.md index 888128304d..8e39003cc7 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/streamline.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/streamline.md @@ -49,7 +49,7 @@ The charts in the **Timeline** view show the performance counter activity captur For instructions to use the features in the **Timeline** view, see the [Streamline User Guide](https://developer.arm.com/documentation/101816/latest/Analyze-your-capture). -Understanding the output of Streamline is key to the usefulness of the tool. To understand how to interpret the capture from different points of view, see [Android performance triage with Streamline](https://developer.arm.com/documentation/102540/latest/). +To understand how to interpret the capture from different points of view, see [Android performance triage with Streamline](https://developer.arm.com/documentation/102540/latest/). ## What you've accomplished and what's next From ce5d976a73e4b20af2c9286e58d24a836c522673 Mon Sep 17 00:00:00 2001 From: anupras-mohapatra-arm Date: Fri, 26 Jun 2026 11:42:39 -0500 Subject: [PATCH 17/18] adding summary and faqs --- .../mobile-graphics-and-gaming/ams/_index.md | 51 ++++++++++++++++++- 1 file changed, 50 insertions(+), 1 deletion(-) diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/_index.md b/content/learning-paths/mobile-graphics-and-gaming/ams/_index.md index a2460d8101..f5431262cd 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/_index.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/_index.md @@ -21,9 +21,57 @@ prerequisites: - Arm Performance Studio installed. Follow the [Arm Performance Studio install guide](/install-guides/ams/) for instructions. - Android SDK Platform tools installed for the Android Debug bridge (adb). +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-06-26T16:37:19Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: 80078c6f05717cbf24c3b695a82fa15bbe477bd14a290195569dda4efe6599ee + summary_generated_at: '2026-06-26T16:37:19Z' + summary_source_hash: 80078c6f05717cbf24c3b695a82fa15bbe477bd14a290195569dda4efe6599ee + faq_generated_at: '2026-06-26T16:37:19Z' + faq_source_hash: 80078c6f05717cbf24c3b695a82fa15bbe477bd14a290195569dda4efe6599ee + summary: >- + You'll profile an Android graphics application on Arm + Mali-based GPUs using Arm Performance Studio. After preparing a debuggable build, you'll + connect an Android device over adb, explore a provided Streamline sample to understand the + available views, then capture a profile from their own application and generate a Performance + Advisor report with the CLI. You'll also perform frame-level inspection with Frame Advisor + and RenderDoc for Arm GPUs, and use Mali Offline Compiler to estimate shader + cost. By the end, you'll understand how to progress from example data to capturing on-device + profiles and interpreting reports that inform deeper frame and shader analysis. + faqs: + - question: How do I launch Streamline and select my Android device? + answer: >- + Open the Performance Studio Hub and launch Streamline. In the Start view, choose Android + (adb) as the device type and select your device from the list. + - question: What should I check in my app build before profiling with Streamline? + answer: >- + Build a debuggable version and include options that facilitate call stack unwinding by Streamline. + For Unity, enable Development Build in Build settings. + - question: What steps import the example Streamline capture? + answer: >- + In Streamline, select File > Import, choose Import Streamline Sample Captures, then select + the Android example and finish. The sample capture is added so you can open it and explore + the views. + - question: How do I generate a Performance Advisor report from a capture? + answer: >- + Open a terminal, navigate to the capture location, and run streamline-cli with the -pa option + on the .apc file (for example, "Android - GPU Bound Example.apc"). The capture is processed + and a Performance Advisor report is produced. + - question: Do I need Python for Performance Advisor? + answer: >- + Yes. Performance Advisor uses a Python script to connect to your device and requires Python + 3.8 or later. +# END generated_summary_faq + author: Ronan Synnott -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false @@ -88,3 +136,4 @@ weight: 1 # _index.md always has weight of 1 to order corr layout: "learningpathall" # All files under learning paths have this same wrapper learning_path_main_page: "yes" # This should be surfaced when looking for related content. Only set for _index.md of learning path content. --- + From c3a78c231d5e3fc84774200df00338976624d318 Mon Sep 17 00:00:00 2001 From: anupras-mohapatra-arm Date: Fri, 26 Jun 2026 11:43:22 -0500 Subject: [PATCH 18/18] nit --- content/learning-paths/mobile-graphics-and-gaming/ams/_index.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/content/learning-paths/mobile-graphics-and-gaming/ams/_index.md b/content/learning-paths/mobile-graphics-and-gaming/ams/_index.md index f5431262cd..100d7a661a 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ams/_index.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ams/_index.md @@ -39,7 +39,7 @@ generated_summary_faq: You'll profile an Android graphics application on Arm Mali-based GPUs using Arm Performance Studio. After preparing a debuggable build, you'll connect an Android device over adb, explore a provided Streamline sample to understand the - available views, then capture a profile from their own application and generate a Performance + available views, then capture a profile from your own application and generate a Performance Advisor report with the CLI. You'll also perform frame-level inspection with Frame Advisor and RenderDoc for Arm GPUs, and use Mali Offline Compiler to estimate shader cost. By the end, you'll understand how to progress from example data to capturing on-device