diff --git a/content/learning-paths/servers-and-cloud-computing/performix-llm-agent-skill/1-what-is-the-skill.md b/content/learning-paths/servers-and-cloud-computing/performix-llm-agent-skill/1-what-is-the-skill.md index bfbe4fd63e..ffd7c99aac 100644 --- a/content/learning-paths/servers-and-cloud-computing/performix-llm-agent-skill/1-what-is-the-skill.md +++ b/content/learning-paths/servers-and-cloud-computing/performix-llm-agent-skill/1-what-is-the-skill.md @@ -1,26 +1,22 @@ --- -title: What is the arm-performix skill? +title: Understand the arm-performix skill +description: Understand how the arm-performix skill selects Arm Performix recipes, gathers workload context, and returns structured profiling reports. weight: 2 ### FIXED, DO NOT MODIFY layout: learningpathall --- -## A skill, not a tool +## What the skill is -**Arm Performix** is a desktop application for hardware-specific performance +Arm Performix is a desktop application for hardware-specific performance tuning. It offers curated analysis pathways for performance-critical factors in -applications, libraries, runtimes, and source code. The **arm-performix skill** is -a set of instructions you add to your AI assistant so that it knows how to use -Performix correctly on your behalf: which recipe to pick, how to gather context, -how to read the results, and how to report findings. +applications, libraries, runtimes, and source code. -Without the skill, an assistant tends to guess at performance problems by reading -your source code. With the skill, it follows a disciplined workflow: measure -first, characterize the bottleneck, change one thing at a time, and confirm the -improvement with before/after data. +The `arm-performix` skill is a set of instructions you can add to your AI assistant so that it knows how to use Performix correctly on your behalf. The skill defines which recipe to pick, how to gather context, how to read the results, and how to report findings. -## What the skill does for you +Without the skill, an assistant might guess at performance problems by reading +your source code. When the skill is active, the assistant: @@ -28,52 +24,39 @@ When the skill is active, the assistant: - Chooses the narrowest Performix recipe that answers your question - Runs the recipe through the `apx` command-line interface (CLI), or through the Arm Model Context Protocol (MCP) Server -- Returns a structured Analysis Report with a bottleneck summary, key metrics, +- Returns a structured analysis report with a bottleneck summary, key metrics, hot functions, ranked recommendations, and a single next step -## What the skill does not do - -- Profile non-Neoverse Arm cores, such as phone-class SoCs -- Guess at bottlenecks from source reading instead of measurement -- Silently switch to another profiler when Performix is unavailable; it asks you - how to proceed instead - -## The recipes it can run +## What recipes the skill can run Performix exposes five profiling recipes, and the skill orchestrates them as a workflow: it picks a starting recipe from your question, then follows the evidence into whichever further recipes are needed to explain and confirm the -bottleneck. Each recipe answers a different question: +bottleneck. + +Each recipe provides a different view of application performance: | Your question | Recipe | What it shows | | --- | --- | --- | -| Where is my time spent? | **Code Hotspots** | Hottest functions, call paths, flame graph | -| Why is the pipeline stalling? | **CPU Microarchitecture** | Front-end and back-end stalls, bad speculation, retiring | -| Am I using single instruction, multiple data (SIMD), such as Neon or Scalable Vector Extension (SVE)? | **Instruction Mix** | Scalar vs vector instruction balance | -| Is memory the bottleneck? | **Memory Access** | L1 cache hit rate, latency, translation lookaside buffer (TLB) and page-walk pressure | -| What can the hardware do? | **System Characterization** | Memory bandwidth and latency baseline per non-uniform memory access (NUMA) node | +| Where is my time spent? | Code Hotspots | Hottest functions, call paths, and flame graphs to identify where time is spent | +| Why is the pipeline stalling? | CPU Microarchitecture | Front-end and back-end pipeline stalls, bad speculation, retiring | +| Am I using single instruction, multiple data (SIMD), such as Neon or Scalable Vector Extension (SVE)? | Instruction Mix | Scalar versus vector instruction balance | +| Is memory the bottleneck? | Memory Access | L1 cache hit rate, latency, translation lookaside buffer (TLB) and page-walk pressure to identify whether memory is the bottleneck | +| What can the hardware do? | System Characterization | Memory bandwidth and latency baseline per non-uniform memory access (NUMA) node to identify what the hardware can do | {{% notice Note %}} -**Where the recipes run:** - -- **Profiling target** (the machine running your workload). The four - microarchitecture-level recipes (CPU Microarchitecture, Instruction Mix, - Memory Access, and System Characterization) require an **Arm Neoverse** target - on Linux; Memory Access additionally needs the Statistical Profiling Extension - (SPE) enabled. Code Hotspots is broader: it also runs on x86-64 Linux and on +- The four microarchitecture-level recipes — CPU Microarchitecture, Instruction Mix, + Memory Access, and System Characterization — require an Arm Neoverse target + on Linux. The Code Hotspots recipe additionally runs on x86-64 Linux and on Windows 11 on Arm or x86-64. -- **Host** (the machine where you run the `apx` CLI or your AI assistant). It can - be macOS, Windows, or Linux on either arm64 or x86-64, and connects to the - target locally or over Secure Shell (SSH). +- To use the Memory Access recipe, enable the Statistical Profiling Extension + (SPE). +- The host machine can be macOS, Windows, or Linux on either arm64 or x86-64. The host can connect to the target locally or over SSH. +- The skill guides AI assistants to use the `apx` CLI by default. If `apx` isn’t installed or available, it asks how you want to proceed rather than switching tools automatically. You can use the Arm MCP Server as an alternative tool, especially if you want fully agent-driven launch-mode profiling. Note that the MCP server doesn’t expose the System Characterization recipe. {{% /notice %}} -{{% notice Note %}} +## What you've learned and what's next -The `apx` CLI is the full-capability interface. Use it for attach-to-process ID -(PID), system-wide captures, timed captures, run export/import, custom result -queries, CI/CD automation, and the System Characterization recipe. The Arm MCP -Server is useful for agent-driven launch-mode profiling, but it exposes only the -`code_hotspots`, `instruction_mix`, `cpu_microarchitecture`, and `memory_access` -recipes. If you need System Characterization or run-history operations, use the -CLI or the graphical user interface (GUI). -{{% /notice %}} +You've now learned how the `arm-performix` skill can help an assistant use Performix correctly, and what Performix recipes the skill can run. + +Next, you'll install the skill and make it discoverable to your AI assistant. diff --git a/content/learning-paths/servers-and-cloud-computing/performix-llm-agent-skill/2-install-the-skill.md b/content/learning-paths/servers-and-cloud-computing/performix-llm-agent-skill/2-install-the-skill.md index 39685f0af2..c42aada36c 100644 --- a/content/learning-paths/servers-and-cloud-computing/performix-llm-agent-skill/2-install-the-skill.md +++ b/content/learning-paths/servers-and-cloud-computing/performix-llm-agent-skill/2-install-the-skill.md @@ -1,18 +1,19 @@ --- -title: Install and enable the skill +title: Install and enable the arm-performix skill +description: Download and install the arm-performix skill, place it in an AI assistant's skills directory, and confirm that the assistant can discover it. weight: 3 ### FIXED, DO NOT MODIFY layout: learningpathall --- -## Get the skill files +## Download the skill folder -Use one of these options to get the skill files. +Use one of the following options to download the skill files: -### Option 1: Clone from Gitee +### Clone skills repository from Gitee -Use this option if you prefer managing the skill source with Git. +If you prefer managing the skill source with Git, clone the skill file from Gitee. From the root of the project where your assistant works, clone the skills repository: @@ -29,23 +30,22 @@ mkdir -p .github/skills cp -R anolis-skills/skills/arm-performix .github/skills/ ``` -### Option 2: Download from SkillHub +### Download package from SkillHub -Use this option if you prefer downloading a package directly from the web. +If you prefer downloading a package directly from the web, download the skill from SkillHub. -Go to the [arm-performix SkillHub page](https://skillhub.openanolis.cn/skill/arm-performix) +Go to the [`arm-performix` SkillHub page](https://skillhub.openanolis.cn/skill/arm-performix) and download the skill. The downloaded skill is a `.zip` package. Extract it, then place the `arm-performix` folder in your assistant's skills directory. -## Place the skill files +## Make the skill folder discoverable -The skill is a folder that contains `SKILL.md`, `README.md`, and a -`references/` directory. Put it where your assistant discovers skills. For GitHub -Copilot in VS Code, use the `.github/skills/` directory of your workspace. Other -assistants use different project directories, such as `.claude/skills/` or -`.agents/skills/`, so use the directory that matches your assistant: +The skill folder contains `SKILL.md`, `README.md`, and a +`references/` directory. Place the folder where your AI assistant discovers skills. + +For GitHub Copilot in VS Code, use the `.github/skills/` directory of your workspace: ```text .github/ @@ -57,36 +57,25 @@ assistants use different project directories, such as `.claude/skills/` or .md ``` -The `SKILL.md` file describes the profiling workflow; `README.md` provides -supporting overview information; and files under `references/` provide detailed +Other assistants use different project directories, such as `.claude/skills/` or +`.agents/skills/`, so use the directory that matches your assistant. + +The `SKILL.md` file describes the profiling workflow. `README.md` provides +supporting overview information. The files under `references/` provide detailed reference materials that the assistant reads on demand. -## Confirm the skill is discovered - -Reload your assistant or IDE, then ask your assistant a profiling question (see -the next page). In VS Code, confirm that Agent Skills are enabled in the -**Configure Chat** skills view or with the `/skills` command. A correctly -installed skill is picked up automatically when your request matches its -triggers; you do not need to invoke it with an explicit command. - -{{% notice Tip %}} -The skill only *describes* how to use Performix. You still need Performix itself -available: either the `apx` CLI on your `PATH`, or the Arm MCP Server configured. -The skill tells you when neither is reachable rather than guessing. -{{% /notice %}} - -## Choose how Performix runs - -The skill can start Performix in two ways. You do not have to pick manually, but -it helps to know which path you have set up: - -- **apx CLI**: the full-capability path. Install it on your host, add the `apx` - directory to your `PATH`, and confirm it with `apx version` from the same - terminal environment your assistant can use. This path works best for remote - Secure Shell (SSH) targets, automation, and CI. -- **Arm MCP Server**: bundles its own `apx`, so your host needs no CLI install. - This path works best for fully agent-driven launch-mode profiling. The skill - routes here only when you ask, or when the CLI is not installed and you confirm - MCP. Use the CLI or GUI for attach-to-process ID (PID), system-wide profiling, - run export/import, custom result queries, CI/CD automation, and System - Characterization. +## Confirm the skill is discoverable + +Reload your assistant or IDE to confirm that it can discover the skill. + +In VS Code, confirm that Agent Skills are enabled in the **Configure Chat** skills view or with the `/skills` command. + +A correctly installed skill is picked up automatically when your request shows profiling or performance intent. You don't need to use a specific command to invoke the skill. + +For prompts you can use to confirm skill discovery, see [Best practices for prompting AI assistants to use the arm-performix skill](/learning-paths/servers-and-cloud-computing/performix-llm-agent-skill/3-trigger-the-skill). + +## What you've accomplished and what's next + +You've now installed the `arm-performix` skill folder and made it discoverable to your AI assistant. + +Next, you'll learn best practices for writing prompts to profile an application using the skill. diff --git a/content/learning-paths/servers-and-cloud-computing/performix-llm-agent-skill/3-trigger-the-skill.md b/content/learning-paths/servers-and-cloud-computing/performix-llm-agent-skill/3-trigger-the-skill.md index 695ba6f883..0f657df382 100644 --- a/content/learning-paths/servers-and-cloud-computing/performix-llm-agent-skill/3-trigger-the-skill.md +++ b/content/learning-paths/servers-and-cloud-computing/performix-llm-agent-skill/3-trigger-the-skill.md @@ -1,40 +1,44 @@ --- -title: Trigger the skill with profiling context +title: Best practices for prompting AI assistants to use the arm-performix skill +description: Write prompts that activate the arm-performix skill by providing profiling intent, an Arm target, an absolute binary path, and a repeatable workload. weight: 4 ### FIXED, DO NOT MODIFY layout: learningpathall --- -## Write a prompt that activates the skill +## Ensure the prompt shows performance and profiling intent -The skill activates on performance and profiling intent. Prompts that work: +The skill activates on performance and profiling intent. + +The following are examples of prompts that show the expected intent: - "Profile this workload on Arm and find the hotspots." - "Why is this binary slow on my Arm Neoverse server?" - "Use Performix to check whether my hot loop uses vector instructions." - "Investigate cache and translation lookaside buffer stalls on my Neoverse target." -Prompts that don't activate the skill: +Prompts that are vague won't activate the skill. + +The following are example vague prompts: -- "Will my code build on Arm?" — a migration question, not a profiling one. -- "Make my code faster" — too vague without a target or binary; add both. +- "Will my code build on Arm?" +- "Make my code faster" ## Provide context up front -The skill needs these details before it can profile. Supplying them in your first -message avoids a round of back-and-forth: +In addition to prompting with the right intent, you need to provide the following context: -1. **Target**: a local Arm machine, or `user@host` for a remote Secure Shell (SSH) target -2. **Binary**: the **absolute path** to the executable on the target -3. **Workload**: the exact command and arguments, ideally repeatable -4. **Goal**: hotspots, vector instruction usage, memory locality, or a regression +1. Target: a local Arm machine, or `user@host` for a remote Secure Shell (SSH) target +2. Binary: the absolute path to the executable on the target +3. Workload: the exact command and arguments, ideally repeatable +4. Goal: hotspots, vector instruction usage, memory locality, or a regression to investigate -If it needs anything else, such as the source tree for line-level attribution or -your build flags, the skill asks rather than guesses. +If the AI assistant needs anything else, such as the source tree for line-level attribution or +your build flags, it'll prompt you for it rather than making an assumption. -A good starting prompt looks like this: +The following is a good starting prompt: ```text Profile /home/me/build/myapp --input /home/me/data/bench.dat on my Arm Neoverse target @@ -42,12 +46,16 @@ me@neoverse-box with Performix. I want to know where the time goes. ``` This prompt gives the assistant the workload command and the SSH target. The -skill picks **Code Hotspots** first, runs it, and reports back with an analysis. - -{{% notice Note %}} -Always give the **absolute path** to the binary, and use absolute paths for input -files, output files, and other files your workload reads or writes. If the -workload must run from a specific directory, tell the assistant that working -directory explicitly. Performix can launch the process from a different working -directory, so relative paths can resolve unexpectedly. -{{% /notice %}} +skill picks Code Hotspots first, runs it, and reports back with an analysis. + +## Provide absolute paths + +Always provide the absolute path to the binary. Use absolute paths for all files your workload reads or writes. + +If the workload must run from a specific directory, include the directory in the prompt. Performix can launch the process from a different working directory, so relative paths can resolve unexpectedly. + +## What you've learned and what's next + +You've now learned how to best structure your prompts to profile an application using the `arm-performix` skill. + +Next, you'll learn how to use generated reports to drive performance improvements. diff --git a/content/learning-paths/servers-and-cloud-computing/performix-llm-agent-skill/4-read-the-report.md b/content/learning-paths/servers-and-cloud-computing/performix-llm-agent-skill/4-read-the-report.md index 7ea65a65f0..42ec670fba 100644 --- a/content/learning-paths/servers-and-cloud-computing/performix-llm-agent-skill/4-read-the-report.md +++ b/content/learning-paths/servers-and-cloud-computing/performix-llm-agent-skill/4-read-the-report.md @@ -1,39 +1,38 @@ --- -title: Read the report and drive the improvement loop +title: Use generated Arm Performix analysis reports to guide improvements +description: Interpret Arm Performix analysis reports from the arm-performix skill and use measured findings to guide application improvements. weight: 5 ### FIXED, DO NOT MODIFY layout: learningpathall --- -## The analysis report +## Structure of an analysis report -After every recipe run, the skill returns a structured report instead of raw -data. Expect these sections: +Every time you run a recipe using the skill, your AI assistant returns a structured report as the primary deliverable. -- **Bottleneck Summary**: what dominates, and how confident the skill is -- **Key Metrics**: the three to five most decision-relevant numbers -- **Hot Functions**: ranked, each with a brief root-cause note -- **Recommended Actions**: concrete, prioritized fixes (file, function, line) -- **Ruled Out**: hypotheses the data did *not* support, and why -- **Next Step**: a single actionable instruction to run next, such as the next - recipe to try or one code change to make, then re-profile +A report contains the following sections: -This report is the skill's primary deliverable. If the data is noisy or -insufficient, the skill says so plainly and recommends a re-run rather than -guessing. +- Bottleneck Summary: what dominates, and how confident the skill is +- Key Metrics: the three to five most decision-relevant numbers +- Hot Functions: a list of hot functions ranked by measured samples, each with a brief root-cause note +- Recommended Actions: suggested fixes by file, function, and line +- Ruled Out: hypotheses the data didn't support, and why +- Next Step: a single actionable instruction to run before re-profiling, such as the next + recipe to try or one code change to make -## A worked example +If the data is noisy or insufficient, you'll receive a recommendation to rerun the recipe. -For a compute-bound workload, a first Code Hotspots report from the skill looks -like this: +## Example Code Hotspots analysis report + +The following is an example first Code Hotspots report for a compute-bound workload: ```markdown ## Performix Analysis Report **Recipe:** Code Hotspots -**Target:** neoverse-box (Arm Neoverse, 64 cores) -**Workload:** /home/me/build/myapp --input /home/me/data/bench.dat +**Target:** `neoverse-box` (Arm Neoverse, 64 cores) +**Workload:** `/home/me/build/myapp --input /home/me/data/bench.dat` ### Bottleneck Summary @@ -45,20 +44,20 @@ a single function, stable across runs. | Metric | Value | Assessment | |--------|-------|------------| -| escape_iterations self % | 72.3% | Critical: single dominant hotspot | -| sqrt self % | 45.1% | Critical: unnecessary math | +| `escape_iterations` self % | 72.3% | Critical: single dominant hotspot | +| `sqrt` self % | 45.1% | Critical: unnecessary math | | Total samples | 48,201 | Good: enough for reliable data | ### Hot Functions | # | Function | Samples (%) | Root Cause | |---|----------|-------------|------------| -| 1 | escape_iterations | 72.3% | sqrt in inner loop | -| 2 | sqrt | 45.1% | magnitude check in escape_iterations | +| 1 | `escape_iterations` | 72.3% | `sqrt` in inner loop | +| 2 | `sqrt` | 45.1% | magnitude check in `escape_iterations` | ### Recommended Actions (priority order) -1. **Remove sqrt** in `mandelbrot.c:22`: replace `sqrt(zr2 + zi2) > 2.0` with +1. **Remove `sqrt`** in `mandelbrot.c:22`: replace `sqrt(zr2 + zi2) > 2.0` with `(zr2 + zi2) > 4.0`. ### Ruled Out @@ -68,38 +67,29 @@ a single function, stable across runs. ### Next Step -Rebuild with the sqrt removal, re-run Code Hotspots, and confirm -escape_iterations falls under 30%. +Rebuild with the `sqrt` removal, re-run Code Hotspots, and confirm +`escape_iterations` falls under 30%. ``` -The report names a file and line, ranks the cost by measured samples, and ends -with a single action you can take immediately, rather than a wall of raw -counters. - -## Expect a two-pass investigation +The skill doesn't let a single Code Hotspots run justify "this is as fast as it +gets." Code Hotspots shows where time goes, never why. -The skill does not let a single Code Hotspots run justify "this is as fast as it -gets." Code Hotspots shows *where* time goes, never *why*. Expect the skill to -propose a **second pass** with a characterizing recipe (CPU Microarchitecture, -Instruction Mix, or Memory Access) to explain why the hot spot is hot. Let it -run that pass before deciding a cost is irreducible. +When you use the skill to run the Code Hotspots recipe, your AI assistant might propose a second pass to explain why the hotspot is hot. Let the assistant run that pass with a characterizing recipe, such as CPU Microarchitecture, Instruction Mix, or Memory Access, before deciding whether a cost is irreducible. -## Drive the improvement loop +## Drive improvements to your application -Work with the skill one change at a time: +Improving your application using the `arm-performix` skill involves the following steps: -1. It establishes a **baseline** run. -2. You or the skill make **one** focused change. -3. It **re-profiles** with the same recipe and workload. -4. It reports a **before/after comparison** with a measurement, not a claim. -5. It looks for the **next bottleneck**, or summarizes the remaining trade-offs. +1. Your AI assistant refers to the skill and establishes a baseline run. +2. You make the suggested focused change and use your assistant to re-profile the code. +3. The assistant refers to the skill and re-profiles with the same recipe and workload. +4. The assistant reports a before-and-after comparison with a measurement. +5. The assistant looks for the next bottleneck or summarizes the remaining trade-offs. -If you want to stop, ask for the remaining opportunities. The skill is designed to -hand you measured options with their trade-offs rather than declare the work -finished on its own. +If you want to stop this flow, ask for the remaining opportunities. The skill is designed so that the AI assistant will hand you measured options with their trade-offs rather than declare the work finished on its own. -{{% notice Tip %}} -If you are using the CLI, you can ask the skill to export a run or render results +{{% notice Note %}} +If you are using the `apx` CLI, you can export a run or render results as JSON: ```bash @@ -109,8 +99,11 @@ apx run render --json Use the `Run ID` from the analysis report, or run `apx run list` to find it. The `` is a directory on the host where Arm Performix writes the -exported `.zip` file. Run export/import and render commands are CLI workflows, -not MCP tool operations. +exported `.zip` file. {{% /notice %}} -You now have a measurement-first workflow for using the arm-performix skill to profile Arm Neoverse workloads, read the results, and make focused improvements. +## What you've learned + +You've now learned how to read reports generated by your AI assistant when you use the `arm-performix` skill, and how to guide improvements with them. + +You can use this measurement-first workflow with the `arm-performix` skill and an AI assistant to profile Arm Neoverse workloads, read the results, and make focused improvements. diff --git a/content/learning-paths/servers-and-cloud-computing/performix-llm-agent-skill/_index.md b/content/learning-paths/servers-and-cloud-computing/performix-llm-agent-skill/_index.md index 80bb2d6bc0..533fc59e0d 100644 --- a/content/learning-paths/servers-and-cloud-computing/performix-llm-agent-skill/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/performix-llm-agent-skill/_index.md @@ -1,15 +1,11 @@ --- -title: Profile and improve Arm workloads with the arm-performix agent skill +title: Get started with the arm-performix agent skill for profiling and improving Arm workloads -draft: true -cascade: - draft: true - -description: Learn how to install and use the arm-performix skill so an AI coding assistant can drive Arm Performix, find code hotspots, diagnose pipeline stalls, and propose measured improvements on Arm Neoverse. +description: Install the arm-performix skill to provide an AI coding assistant profiling context so it can drive Arm Performix, find code hotspots, diagnose pipeline stalls, and propose measured improvements on Arm Neoverse. minutes_to_complete: 30 -who_is_this_for: This is an introductory topic for developers who use an AI coding assistant with Agent Skills support, such as GitHub Copilot in VS Code or Claude Code, and want the arm-performix skill to drive Arm Performix profiling workflows without memorizing the `apx` command-line interface. +who_is_this_for: This is an introductory topic for developers who use an AI coding assistant with Agent Skills support, such as GitHub Copilot in VS Code or Claude Code, and want the arm-performix skill to drive Arm Performix profiling workflows without memorizing the apx command-line interface. learning_objectives: - Install and enable the arm-performix skill in your AI assistant @@ -18,13 +14,59 @@ learning_objectives: - Read the analysis report the skill produces and drive the improvement loop prerequisites: - - An AI assistant with Agent Skills support enabled, such as GitHub Copilot in VS Code or Claude Code - - An Arm Neoverse-based Linux instance reachable from the assistant's environment - - Arm Performix installed with the `apx` command-line interface available on the host `PATH`, or the Arm Model Context Protocol (MCP) Server configured for supported launch-mode profiling recipes + - An AI assistant with Agent Skills support enabled, such as [GitHub Copilot in VS Code](/install-guides/github-copilot/) or [Claude Code](/install-guides/claude-code/) + - An Arm Neoverse-based Linux instance reachable from the assistant's environment. If you need an instance, complete the [Get started with Arm-based cloud instances Learning Path](/learning-paths/servers-and-cloud-computing/csp/) + - Arm Performix installed with access to a supported execution method, such as the `apx` CLI, on the host `PATH`. For more information, see the [Arm Performix install guide](/install-guides/performix/). The skill guides AI assistants to use the `apx` CLI by default. + +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-07-23T15:07:40Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: 33576a961d9992d8b8e5a6ef65080d58561f4d98d226b0a0dfa990bceffed0bf + summary_generated_at: '2026-07-23T15:07:40Z' + summary_source_hash: 33576a961d9992d8b8e5a6ef65080d58561f4d98d226b0a0dfa990bceffed0bf + faq_generated_at: '2026-07-23T15:07:40Z' + faq_source_hash: 33576a961d9992d8b8e5a6ef65080d58561f4d98d226b0a0dfa990bceffed0bf + summary: >- + You’ll install the `arm-performix` skill and learn how to activate it with a performance-focused prompt. You’ll learn that you need to provide an Arm Neoverse target, an absolute binary path, a repeatable workload, and a profiling goal in your prompts. Then, you'll interpret an example structured analysis report and learn how to use a report's recommendations to guide measured improvements. + faqs: + - question: How do I install the arm-performix skill using Git? + answer: >- + Clone the skills repository, then copy the `arm-performix` folder into your project’s skills directory. + - question: Do I need to run the apx CLI myself, or does the skill handle it? + answer: >- + You don't need to run `apx` CLI commands manually. The skill guides AI assistants to use the `apx` CLI by default. Ensure Arm Performix is installed + and `apx` is available on the host `PATH`. + - question: How do I write prompts to activate the arm-performix skill? + answer: >- + Use clear profiling intent, for example: "Profile this workload on Arm and find the hotspots", + "Why is this binary slow on my Arm Neoverse server?", "Use Performix to check whether my + hot loop uses vector instructions", or "Investigate cache and translation lookaside buffer + stalls on my Neoverse target". Vague prompts are less effective. + - question: What context should I include so the skill can profile correctly? + answer: >- + State the target (Arm Neoverse-based Linux instance), an absolute path to the binary to analyze, how to run the workload, and the profiling goal. Provide any run arguments the assistant needs to execute the + binary. + - question: What should I expect after the skill completes a profiling run? + answer: >- + Expect a structured analysis report with sections such as "Bottleneck Summary", "Key Metrics", + "Hot Functions", "Recommended Actions", "Ruled Out", and "Next Step". Use "Recommended Actions" + and "Next Step" to drive code changes, then ask the assistant to rerun the recipe to validate + the result. +# END generated_summary_faq author: - Henry Wang +generate_summary_faq: false +rerun_summary: false +rerun_faqs: false + ### Tags skilllevels: Introductory subjects: Performance and Architecture @@ -57,11 +99,10 @@ further_reading: link: /learning-paths/servers-and-cloud-computing/performix-memory-access/ type: learning-path - - ### FIXED, DO NOT MODIFY # ================================================================================ weight: 1 # _index.md always has weight of 1 to order correctly 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. --- +