# Arm System Characterization Tool (ASCT)

## About this Install Guide

| Reading time:      | 15 min        |
|---------------------|---------------|
| Last updated:       | 27 Jul 2026   |

This guide shows you how to install and use the tool with the most common configuration. For advanced options and complete reference information, see the official documentation. Some install guides also include optional next steps to help you explore related workflows or integrations.

The Arm System Characterization Tool (ASCT) is a command-line utility for running low-level benchmarks, diagnostic scripts, and system tests to analyze and debug performance on Arm-based platforms. ASCT provides a standardized environment for evaluating key hardware characteristics and is especially suited for platform bring-up, system tuning, and architectural comparison tasks.

ASCT provides capabilities for:

- Memory latency and bandwidth benchmarking across NUMA nodes
- Storage I/O performance testing
- System hardware and software configuration reporting
- Core-to-core latency measurements
- Cache hierarchy mapping through sweep operations

ASCT is available for Linux on Arm (AArch64) systems.

## Before you begin

ASCT requires a Linux system running on Arm hardware. To confirm you are using an Arm computer with 64-bit Linux, run:

```
uname -m
```

The output should be:

```
__output__ aarch64
```

If you see a different result, you are not using an Arm computer running 64-bit Linux.

### Install prerequisites

Before installing ASCT, ensure that you have the required system packages:

```
sudo apt update
sudo apt install python3 python3-pip python-is-python3 gcc make libc6-dev numactl fio linux-tools-generic linux-tools-$(uname -r) -y
```

These packages are needed for:

- `python3` — Python 3.10 or later for running ASCT
- `gcc`, `make`, and `libc6-dev` — for compiling benchmark components
- `numactl` — for NUMA-aware memory benchmarks
- `fio` — version 3.36 or later for storage benchmarks
- `linux-tools-generic` and `linux-tools-$(uname -r)` — Linux Perf for performance analysis

For more information about installing Perf on different Linux distributions, see the [Perf install guide](https://learn.arm.com/install-guides/perf/).

## Download and install ASCT

ASCT is distributed as a Python package and requires Python 3.10 or later.

### Download ASCT

Download ASCT version `0.6.0`:

```
wget https://artifacts.tools.arm.com/asct/dist/0.6.0/asct-0.6.0+6324f8f-release.tar.gz
```

### Install ASCT using uv

The recommended method uses [uv](https://github.com/astral-sh/uv), a fast Python package installer. Install `uv`:

```
curl -LsSf https://astral.sh/uv/install.sh | sh
```

Add `uv` to your `PATH` for the current session:

```
source $HOME/.local/bin/env
```

Extract the release archive:

```
tar xzf asct-0.6.0+6324f8f-release.tar.gz
```

Create the required directories:

```
sudo mkdir -p /opt/uv/tools /usr/local/bin
```

Install ASCT system-wide using:

```
cd asct-0.6.0+6324f8f
sudo UV_TOOL_DIR=/opt/uv/tools UV_TOOL_BIN_DIR=/usr/local/bin $(which uv) tool install ./asct-0.6.0+6324f8f.tar.gz
```

This installs ASCT to `/usr/local/bin` making it available system-wide. Installing to `/usr/local/bin` instead of the default `~/.local/bin` allows you to run ASCT with `sudo`, which is required for some benchmarks to access system resources and configure huge pages.

### Verify that ASCT is installed

Verify the installation by checking the version:

```
asct version
```

The output is similar to:

```
__output__ ASCT 0.6.0+6324f8f
```

Display the help information:

```
asct --help
```

This displays available commands and benchmarks.

## How to use ASCT

ASCT provides several commands for benchmarking and system analysis, including `run`, `system-info`, `list`, `diff`, and `sysreg`.

### Get system information

To generate a system information report, run:

```
sudo asct system-info
```

To save the system information in JSON format, run:

```
sudo asct system-info --format json --output-dir my_output
```

### List available benchmarks

To list all available benchmarks and their associated keywords, run:

```
asct list
```

### Run benchmarks

To run the default set of benchmarks, run:

```
sudo asct run
```

To run all available benchmarks (including optional ones), run:

```
sudo asct run all
```

To run specific benchmarks by name, run:

```
sudo asct run latency-sweep idle-latency
```

Each benchmark has associated keywords that describe its characteristics. You can use these keywords to run groups of related benchmarks without specifying each one individually.

To run all benchmarks tagged with the `memory` keyword, run:

```
sudo asct run memory
```

To run all benchmarks tagged with both `latency` and `bandwidth` keywords, run:

```
sudo asct run latency bandwidth
```

Common keywords include `memory`, `storage`, `latency`, `bandwidth`, `sweep`, and `long-runtime`. Use `asct list` to see which keywords are associated with each benchmark.

To exclude benchmarks by keyword, prepend the keyword with the `^` character, run:

```
sudo asct run all ^bandwidth
```

This command runs all benchmarks except those tagged with the `bandwidth` keyword.

To save benchmark results in CSV format, run:

```
sudo asct run --format csv --output-dir results
```

By default, ASCT saves output in a directory named `data.<YYYYMMDD_HHMMSS_microseconds>` in the current working directory. Use `--output-dir` to specify a custom location.

### Compare results

To compare results from multiple ASCT runs, run:

```
asct diff --output-dir results1 --output-dir results2
```

## Available benchmarks on ASCT

ASCT includes several categories of benchmarks:

Memory benchmarks:

- `latency-sweep` (`ls`) - Measures memory latency across data sizes from 128 bytes to 1 GiB, revealing cache hierarchy transitions. Uses 1 GiB huge pages to reduce TLB impact. Calculates optimal data sizes for L1, L2, LLC, and DRAM.
- `idle-latency` (`il`) - Reports a matrix of idle memory latency across NUMA nodes
- `peak-bandwidth` (`pb`) - Measures peak memory bandwidth
- `cross-numa-bandwidth` (`cnb`) - Measures cross-NUMA node memory bandwidth
- `bandwidth-sweep` (`bs`) - Sweeps bandwidth by data size to map cache hierarchy
- `loaded-latency` (`ll`) - Measures memory latency under load conditions (not run by default)
- `c2c-latency` (`ccl`) - Measures core-to-core communication latency

Storage benchmarks:

- `storage-request-size-sweep` (`srss`) - Sweeps I/O request sizes to measure performance
- `storage-io-depth-sweep` (`sids`) - Sweeps I/O queue depths to find optimal settings
- `storage-process-count-sweep` (`spcs`) - Sweeps process counts to measure scaling
- `storage-access-pattern-sweep` (`saps`) - Evaluates different workload profiles including sequential and random access (not run by default)

You can filter benchmarks using keywords such as `latency`, `bandwidth`, `memory`, `storage`, `sweep`, or `long-runtime`.

## Output formats supported by ASCT

ASCT supports three output formats:

- `stdout` - Human-readable console output (default)
- `csv` - Individual CSV files for each benchmark (for example, `benchmark-name.csv`)
- `json` - Single combined JSON file (`report.json`) containing all results

Specify the format using the `--format` or `-f` option:

```
sudo asct run --format json
```

## Other available options on ASCT

ASCT provides several additional options:

- `--log-level` or `-L` - Set logging verbosity (debug, info, warning, error, critical)
- `--log-file` - Save logs to a specific file
- `--force` - Overwrite existing output directory
- `--quiet` or `-q` - Disable all output to stdout and stderr
- `--no-progress-bar` - Use single-line updates instead of animated progress bar
- `--dry-run` - Show which benchmarks would run without executing them
- `--no-cache` - Disable cached benchmark data
- `--clear-cache` - Clear cached benchmark data

Setting `--log-level` to `debug` is useful if the tests are not running due to permission settings or a missing software dependency.

Some of the tests also generate graphs.

The following is an example of a bandwidth graph:

![Bandwidth sweep benchmark results](https://learn.arm.com/install-guides/_images/asct-bw.webp)  
*Bandwidth sweep benchmark results*

## Uninstall ASCT

If you installed ASCT using `uv`, remove it with:

```
sudo -E $(which uv) tool uninstall asct
```

## More information about ASCT

ASCT is open source and available on GitHub at [https://github.com/Arm/asct](https://github.com/Arm/asct). You can browse the source code, report issues, and contribute to the project.

To get detailed information about any ASCT command, run the built-in help command:

```
asct help <command>
```

For example:

```
asct help run
```

You are now ready to use ASCT for analyzing performance on Arm-based platforms.