Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
Expand Up @@ -6,15 +6,59 @@ minutes_to_complete: 15
who_is_this_for: This is an introductory guide for developers who want to measure and optimize the performance of applications running on Arm Neoverse™-based servers.

learning_objectives:
- Describe Arm's top-down profiling methodology.
- Identify the Arm top-down profiling methodology.
- Use Streamline CLI tools to capture and analyze performance data from an application.

prerequisites:
- An Arm Neoverse-based (N1, N2 or V1) computer running Linux. For your host OS, you can use Amazon Linux 2023 or newer, Debian 10 or newer, RHEL 8 or newer, or Ubuntu 20.04 or newer.
- An Arm Neoverse-based (N1, N2 or V1) computer running Amazon Linux 2023 or later, Debian 10 or later, RHEL 8 or later, or Ubuntu 20.04 or later

# START generated_summary_faq
generated_summary_faq:
template_version: summary-faq-v3
generated_at: '2026-11-19T15:57:10Z'
generator: ai
ai_assisted: true
ai_review_required: true
model: gpt-5
prompt_template: summary-faq-v3
source_hash: 2869c5b6c97f5a7b831917816ddfd0358987f040072a1ae5466ff1eb46ffec1c
summary_generated_at: '2026-11-19T15:57:10Z'
summary_source_hash: 2869c5b6c97f5a7b831917816ddfd0358987f040072a1ae5466ff1eb46ffec1c
faq_generated_at: '2026-11-19T15:57:10Z'
faq_source_hash: 2869c5b6c97f5a7b831917816ddfd0358987f040072a1ae5466ff1eb46ffec1c
summary: >-
You'll profile applications on Arm Neoverse Linux servers with Streamline CLI tools and
top-down analysis. First, you'll check hardware profiling support with Arm Sysreport and
learn how pipeline slots reveal performance bottlenecks. You'll then build with debug
information, capture samples with `sl-record`, analyze them with `sl-analyze`, and format
the report with `sl-format.py`. Finally, you'll use function metrics to prioritize
optimization.
faqs:
- question: How do I check whether my system supports hardware-assisted profiling?
answer: >-
Run Arm Sysreport and review its performance counter and Statistical Profiling Extension
(SPE) entries. You can see the available CPU counters and whether SPE is present.
- question: How do I include function names in the report?
answer: >-
Build your application with debug information before recording. You can then map sampled
instructions to functions in the analysis.
- question: Which Streamline CLI tools do I run, and in what order?
answer: >-
Use `sl-record` to capture samples, `sl-analyze` to create function metrics, and
`sl-format.py` to format the results.
- question: Which metrics help me identify a bottleneck?
answer: >-
Review `Retiring%`, `FE bound%`, `Bad spec%`, and `BE bound%` in the functions report.
You can use their relative values to decide which functions need closer inspection.
- question: What can I try if a hot function has instruction cache misses?
answer: >-
Consider profile-guided optimization to reduce less important code and leave more
instruction cache space for critical paths. Measure again to check the effect.
# END generated_summary_faq

author: Julie Gaskin

generate_summary_faq: true
generate_summary_faq: false
rerun_summary: false
rerun_faqs: false

Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -6,21 +6,63 @@ minutes_to_complete: 30
who_is_this_for: This is an introductory topic for developers deploying and optimizing Puppet workloads on Arm Linux environments, specifically using Google Cloud C4A virtual machines powered by Axion processors.

learning_objectives:
- Provision an Arm-based SUSE SLES (SUSE Linux Enterprise Server) virtual machine (VM) on Google Cloud C4A with Axion processors
- Install Puppet on a SUSE Arm64 C4A instance
- Verify Puppet by applying a test manifest and confirming successful resource creation on Arm64
- Benchmark Puppet by measuring catalog compile time, apply speed, and resource usage on Arm64
- Provision an Arm-based SUSE SLES (SUSE Linux Enterprise Server) virtual machine (VM) on Google Cloud C4A with Axion processors.
- Install Puppet on a SUSE Arm64 C4A instance.
- Verify Puppet by applying a test manifest and confirming successful resource creation on Arm64.
- Benchmark Puppet by measuring catalog compile time, apply speed, and resource usage on Arm64.

prerequisites:
- A [Google Cloud Platform (GCP)](https://cloud.google.com/free) account with billing enabled
- Basic familiarity with [Puppet](https://www.puppet.com/)

# START generated_summary_faq
generated_summary_faq:
template_version: summary-faq-v3
generated_at: '2026-11-19T15:57:44Z'
generator: ai
ai_assisted: true
ai_review_required: true
model: gpt-5
prompt_template: summary-faq-v3
source_hash: ed729f599b63ca1094a46c3e2623e876345f833c37bc265a985acc718df8ffde
summary_generated_at: '2026-11-19T15:57:44Z'
summary_source_hash: ed729f599b63ca1094a46c3e2623e876345f833c37bc265a985acc718df8ffde
faq_generated_at: '2026-11-19T15:57:44Z'
faq_source_hash: ed729f599b63ca1094a46c3e2623e876345f833c37bc265a985acc718df8ffde
summary: >-
You'll install and validate Puppet on a Google Axion C4A VM running SUSE Linux. After
provisioning a `c4a-standard-4` instance, you'll install dependencies and build Ruby before
installing Puppet. You'll then check Puppet and Facter versions, apply a test manifest, and
inspect the created resource. Finally, you'll run a standalone benchmark to measure local
catalog compilation and apply performance.
faqs:
- question: Which machine type and image should I select?
answer: >-
Choose `c4a-standard-4` and a SUSE Linux Enterprise Server arm64 image.
- question: Which command do I use to run the standalone Puppet benchmark?
answer: >-
Run `time puppet apply benchmark.pp --verbose` from `~/puppet-benchmark`.
You can review the catalog compilation and elapsed time in the output.
- question: How do I verify Puppet and Facter before applying a manifest?
answer: >-
Run `puppet --version` and `facter --version`. You should see a version from each
command.
- question: How do I verify that the test manifest worked?
answer: >-
Apply the manifest, then run `cat /tmp/puppet_test.txt` to inspect the file that it creates.
You can also review the Puppet resource change output.
- question: Where do I put the benchmark manifest?
answer: >-
Create `~/puppet-benchmark` and place the provided manifest there. You can then run the
benchmark and record its catalog compile time, apply speed, and resource usage.
# END generated_summary_faq

author: Pareena Verma

generate_summary_faq: true
generate_summary_faq: false
rerun_summary: false
rerun_faqs: false

prerequisites:
- A [Google Cloud Platform (GCP)](https://cloud.google.com/free) account with billing enabled
- Basic familiarity with [Puppet](https://www.puppet.com/)

##### Tags
skilllevels: Introductory
subjects: Performance and Architecture
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -3,7 +3,7 @@ title: Run a PyTorch LLM chatbot with KleidiAI on Arm

minutes_to_complete: 30

who_is_this_for: This is an introductory topic for software developers interested in running LLMs using PyTorch on Arm-based servers.
who_is_this_for: This is an introductory topic for software developers interested in running large language models (LLMs) using PyTorch on Arm-based servers.

learning_objectives:
- Download the Meta Llama 3.1 model from the Meta Hugging Face repository.
Expand All @@ -13,14 +13,55 @@ learning_objectives:
- Measure performance metrics of the LLM inference running on an Arm-based CPU.

prerequisites:
- An [Arm-based instance](/learning-paths/servers-and-cloud-computing/csp/) with at least 16 CPUs from a cloud service provider or an on-premise Arm server.
- An [Arm-based instance](/learning-paths/servers-and-cloud-computing/csp/) with at least 16 CPUs from a cloud service provider, or an on-premise Arm server

# START generated_summary_faq
generated_summary_faq:
template_version: summary-faq-v3
generated_at: '2026-11-19T15:58:37Z'
generator: ai
ai_assisted: true
ai_review_required: true
model: gpt-5
prompt_template: summary-faq-v3
source_hash: de0c91f69925ca664abbb3d7383c52a0196ecf72864260599ef6afbf4032319c
summary_generated_at: '2026-11-19T15:58:37Z'
summary_source_hash: de0c91f69925ca664abbb3d7383c52a0196ecf72864260599ef6afbf4032319c
faq_generated_at: '2026-11-19T15:58:37Z'
faq_source_hash: de0c91f69925ca664abbb3d7383c52a0196ecf72864260599ef6afbf4032319c
summary: >-
You'll run a PyTorch chatbot with KleidiAI INT4 kernels on an Arm server. First, you'll prepare
a Python environment and download Meta Llama 3.1 from Hugging Face. You'll quantize the model
to four bits and run CPU inference. Then, you'll start the Torchchat backend and Streamlit
frontend, test a prompt in the browser, and capture basic inference performance
measurements.
faqs:
- question: What Arm server do I need before starting?
answer: >-
Use an Arm server with Ubuntu 24.04 LTS, at least 16 cores, 64 GB of memory, and 50 GB
of storage. You can use the tested AWS Graviton4 `r8g.4xlarge` setup as reference.
- question: Which model do I download?
answer: >-
Download Meta Llama 3.1 from its Meta repository on Hugging Face.
- question: Which Python environment do I activate for the frontend?
answer: >-
Run `source torch_env/bin/activate` before you install the frontend dependencies.
- question: How do I resolve the httpx proxies error?
answer: >-
Install `httpx==0.27.2`, then restart the
frontend.
- question: How do I check that the chatbot works end to end?
answer: >-
Start the Torchchat backend and Streamlit frontend. Open the web interface, enter a
prompt, and check that you receive a model response.
# END generated_summary_faq

author:
- Nikhil Gupta
- Pareena Verma
- Nobel Chowdary Mandepudi

generate_summary_faq: true
generate_summary_faq: false
rerun_summary: false
rerun_faqs: false

Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -7,21 +7,62 @@ minutes_to_complete: 30
who_is_this_for: This is an introductory topic for developers, data engineers, and platform engineers who want to build semantic search systems and chatbot retrieval pipelines on Arm64-based Google Cloud C4A Axion processors using the Qdrant vector database.

learning_objectives:
- Deploy and run the Qdrant vector database on Google Cloud C4A Axion processors
- Generate vector embeddings using transformer models
- Store and index embeddings efficiently using Qdrant
- Perform semantic similarity search using vector queries
- Build a simple chatbot retrieval system powered by vector search
- Deploy and run the Qdrant vector database on Google Cloud C4A Axion processors.
- Generate vector embeddings using transformer models.
- Store and index embeddings efficiently using Qdrant.
- Perform semantic similarity search using vector queries.
- Build a simple chatbot retrieval system powered by vector search.

prerequisites:
- A [Google Cloud Platform (GCP)](https://cloud.google.com/free) account with billing enabled
- Basic familiarity with Python
- Basic understanding of machine learning embeddings
- Familiarity with Linux command-line operations

# START generated_summary_faq
generated_summary_faq:
template_version: summary-faq-v3
generated_at: '2026-11-19T15:59:16Z'
generator: ai
ai_assisted: true
ai_review_required: true
model: gpt-5
prompt_template: summary-faq-v3
source_hash: 439ba306b67ab6a2e1f442ab548e8d6eb330b90f52434fa2a8ee6143a1bb944b
summary_generated_at: '2026-11-19T15:59:16Z'
summary_source_hash: 439ba306b67ab6a2e1f442ab548e8d6eb330b90f52434fa2a8ee6143a1bb944b
faq_generated_at: '2026-11-19T15:59:16Z'
faq_source_hash: 439ba306b67ab6a2e1f442ab548e8d6eb330b90f52434fa2a8ee6143a1bb944b
summary: >-
You'll deploy Qdrant on a Google Axion C4A VM and use vector embeddings for semantic search.
You'll provision a SUSE Linux arm64 instance, prepare Qdrant, and generate embeddings from
sample text with Sentence Transformers. After storing the vectors in a Qdrant collection,
you'll run similarity queries and connect retrieval to a chatbot. You can then test whether
responses use relevant stored content.
faqs:
- question: What do I need before provisioning the virtual machine?
answer: >-
You need a Google Cloud account with billing enabled.
- question: Which C4A machine type should I choose?
answer: >-
Select `c4a-standard-4` in the Google Cloud console.
- question: Which operating system image should I use?
answer: >-
Choose a SUSE Linux Enterprise Server arm64 image for the C4A VM.
- question: What should I see after indexing embeddings?
answer: >-
You should have a Qdrant collection containing vectors generated from the sample text.
You can then query that collection for similar content.
- question: How do I check whether semantic search is working?
answer: >-
Run a similarity query and inspect the ranked matches. If the matches seem unrelated, check
that you inserted the embeddings. Ensure that you used the same Sentence Transformers model for
indexing and querying.
# END generated_summary_faq

author: Pareena Verma

generate_summary_faq: true
generate_summary_faq: false
rerun_summary: false
rerun_faqs: false

Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -8,19 +8,64 @@ minutes_to_complete: 60
who_is_this_for: This is an advanced topic for developers who want to build and benchmark QuantLib on Arm-based cloud instances.

learning_objectives:
- Understand why QuantLib is a useful benchmark for Arm-based cloud systems
- Create and connect to an Arm64 Azure Cobalt virtual machine running Ubuntu
- Build QuantLib from source with benchmark support enabled
- Run QuantLib benchmark workloads with different sizes and thread counts
- Record and compare benchmark results in a repeatable way
- Identify why QuantLib is a useful benchmark for Arm-based cloud systems.
- Create and connect to an Arm64 Azure Cobalt virtual machine running Ubuntu.
- Build QuantLib from source with benchmark support enabled.
- Run QuantLib benchmark workloads with different sizes and thread counts.
- Record and compare benchmark results in a repeatable way.

prerequisites:
- An Azure account with permission to create virtual machines
- Basic familiarity with the Linux command line and SSH
- Basic experience building C++ software from source

# START generated_summary_faq
generated_summary_faq:
template_version: summary-faq-v3
generated_at: '2026-11-19T15:59:43Z'
generator: ai
ai_assisted: true
ai_review_required: true
model: gpt-5
prompt_template: summary-faq-v3
source_hash: 7a0e1bc938569aaa47aa021d5993f8f40503ed629fbe97eee8d99cec5d2ed3d8
summary_generated_at: '2026-11-19T15:59:43Z'
summary_source_hash: 7a0e1bc938569aaa47aa021d5993f8f40503ed629fbe97eee8d99cec5d2ed3d8
faq_generated_at: '2026-11-19T15:59:43Z'
faq_source_hash: 7a0e1bc938569aaa47aa021d5993f8f40503ed629fbe97eee8d99cec5d2ed3d8
summary: >-
You'll build and benchmark QuantLib on an Azure Cobalt-based Arm virtual machine. You'll provision an Ubuntu
virtual machine and build QuantLib from source with benchmark support and CPU-specific compiler flags. Then, you'll
run the benchmark executable. After a baseline run, you'll keep the workload size fixed and
change the number of worker processes. You'll then compare reported throughput and runtime
across runs to study scaling.
faqs:
- question: What Azure virtual machine configuration should I use?
answer: >-
Choose an Arm64 VM in a region that offers Azure Cobalt, such as West US 2. Use the `Standard_D4ps_v5` machine type and
Ubuntu Server 22.04 LTS.
- question: Where do I run the QuantLib benchmark?
answer: >-
Change to `~/QuantLib-$QL_VER/test-suite` and run `./quantlib-benchmark` after the
build.
- question: How do I vary workload size or worker count?
answer: >-
Use `--size` for the workload size and `--nProc` for the number of worker processes.
Keep `--size` fixed when you compare worker counts.
- question: How do I check that benchmark support was built?
answer: >-
Use the source `--enable-benchmark` configure option and `CFLAGS` and `CXXFLAGS`
settings. You'll then find a runnable `quantlib-benchmark` executable in the test
suite.
- question: What should I record from each benchmark run?
answer: >-
Record your `--size` and `--nProc` values alongside reported throughput in tasks per
second and runtime. You can compare your runs with the example results.
# END generated_summary_faq

author: Chris Moroney

generate_summary_faq: true
generate_summary_faq: false
rerun_summary: false
rerun_faqs: false

Expand Down
Loading
Loading