Repository navigation
Graphic Interface
This page covers the installation and basic usage of the Mess graphical user interface (GUI).
The GUI is a desktop application that runs the same Mess benchmark used by the command-line interface. It compiles and starts the mess binary in the background, follows its progress, and presents the resulting bandwidth-latency curves and performance metrics in a graphical interface.
Note: The GUI does not implement a separate benchmark. Measurements produced through the GUI and command-line interface use the same Mess backend and methodology.
Download the package for your platform from the Mess releases page or Mess website
You can also download a release from a terminal. Replace <VERSION> and <PACKAGE> with the release tag and filename shown on the releases page:
curl -LO https://github.com/bsc-mem/Mess/releases/download/<VERSION>/<PACKAGE>| Platform | Package | Installation |
|---|---|---|
| Linux x86-64 | .deb |
Run sudo apt install ./mess-gui-<version>-linux-x86_64.deb
|
| Linux x86-64 | .AppImage |
Mark the file executable and run it directly |
| Linux ARM64 |
.deb or .AppImage
|
Use the corresponding linux-aarch64 package |
| macOS | Universal .dmg
|
Open the disk image and drag Mess to Applications |
| Windows x86-64 |
.exe installer |
Run the installer and follow the setup wizard |
On Windows, the installer creates a desktop shortcut that requests administrator privileges automatically. If you launch the application another way, use Run as administrator so Mess can access the memory-controller counters.
The GUI needs access to a Mess checkout. On first launch, choose one of the following options:
| Choice | When to pick it | What it does |
|---|---|---|
| Locate existing Mess | You already cloned Mess | Select the checkout or any folder inside it, the GUI locates and remembers the repository root |
| Install Mess | You do not have a checkout | Select a destination and let the GUI download and configure the official Mess repository |
The selected checkout remains in its original location. The GUI remembers it for future launches and compiles Mess automatically when required.
Before displaying the run options, the GUI checks that:
- The Mess checkout is valid and compiled
- The system and memory configuration can be detected
- A supported bandwidth-counter backend is available
- The process has permission to read the required counters
- The Python modules used for processed exports are installed
The system panel at the bottom of the main screen shows the detected operating system, processor, core count, memory configuration, bandwidth backend, and any condition that could prevent a reliable measurement. Use Advanced to display the complete detection report.
If a blocking condition is fixed outside the application, select Recheck system to run detection again without restarting the GUI.
The benchmark and the GUI's built-in result charts work without the plotting packages. If they are missing, the GUI displays the Bash or PowerShell commands required to install them. You can copy those commands, install the packages, and select Check again.
You may also select Continue without them. Measurements and built-in charts will still work, but the processed PDF and CSV exports normally generated through the Python plotting tools will be unavailable.
The main screen provides two measurement modes:
| Mode | Typical duration | Coverage | Main results |
|---|---|---|---|
| Full run | Hours | Every read/write ratio from idle through saturation | Complete bandwidth-latency curves, aggregate metrics, and Mess Score |
| Quick evaluation | Minutes | Three representative read/write mixes | Peak bandwidth for 100%, 50%, and 0% reads, plus unloaded latency |
Both modes save their raw and processed data inside the selected Mess checkout.
A full run generates the complete family of Mess bandwidth-latency curves. Before starting, select the level of detail:
| Tier | Points per ratio | Typical duration | Recommended use |
|---|---|---|---|
| Lite | 15 | About 1 hour; about 6 hours on macOS | A fast view of each curve and its saturation knee |
| Standard | 50 | About 6 hours; about 48 hours on macOS | General characterization and comparisons; recommended default |
| Detailed | 200 | About 24 hours; about 192 hours on macOS | Publication plots and detailed analysis near saturation |
The selected tier is equivalent to the command-line option --tier=lite, --tier=standard, or --tier=detailed. Every tier measures the same read/write ratios, higher tiers sample each curve more densely.
Full runs take longer on macOS because each point uses a longer measurement window to reduce OS scheduler noise.
While the benchmark runs, the GUI reports the current stage, completed points, and estimated time remaining.
After the measurements finish, the GUI processes the data and displays:
- The complete bandwidth-latency curves for every read/write ratio
- Peak measured bandwidth and the ratio that achieved it
- Peak sustained bandwidth, calculated across the measured ratios
- Unloaded memory latency
- The Mess Score on a scale from 0 to 100
- Comparisons with theoretical bandwidth when the memory configuration is known
The Mess Score summarizes bandwidth and latency quality across the complete curve family. Higher values indicate that the measured curves remain closer to the theoretical capability of the system. It is calculated only for a complete full run and may show n/a when the theoretical peak is unavailable.
Quick evaluation provides a short overview of the platform without measuring the entire curve family. It measures three representative requested read ratios:
- 100% reads
- 50% reads
- 0% reads
For each mix, the GUI discovers and reports its peak bandwidth and the loaded latency at that point. It also performs a separate low-traffic probe to measure unloaded latency.
The results screen displays:
- Unloaded latency on an idle memory system
- Peak bandwidth for each of the three mixes
- Loaded latency at each peak
- The percentage of theoretical bandwidth achieved, when available
- A backpressure warning when full-load bandwidth drops meaningfully below the measured peak
Quick evaluation does not produce a Mess Score because three ratios do not represent the complete curve family.
Every run is saved automatically under the selected Mess checkout. Folder names include the mode and local date and time:
measuring_gui_full_YYYY-MM-DDTHH-MM-SS
measuring_gui_quick_YYYY-MM-DDTHH-MM-SS
The run folder contains the raw measurements and processed data used by the result screen. When the plotting dependencies are available, Mess also produces processed curve data and plotting exports.
Select Save as PNG and PDF on a result screen to export the complete screen. The GUI creates a results/ directory inside that run's folder and saves both formats there.
Select Previous results in the upper-right corner of the main screen to review saved measurements. Full runs and quick evaluations are listed separately, newest first.
Each entry provides the available headline metrics and the following actions:
- View results reopens the original result screen
- Open folder reveals the raw and processed files in the system file manager
- Delete permanently removes that run's raw measurements and processed results
The GUI reads this history directly from the run folders each time the page opens. Moving or deleting a folder outside the application therefore changes what appears in the history.
Warning: Deleting a run from Previous results cannot be undone. Long full runs may represent many hours of measurement.
The system panel explains the closest known cause when the GUI cannot access a bandwidth backend. Fix the reported condition and select Recheck system. See Installation and FAQ for broader build and measurement guidance.
The most common issue is restricted access to hardware performance counters. If kernel.perf_event_paranoid blocks Mess, the GUI offers two options:
- Select Grant access and approve the desktop authentication prompt
- Copy and run the displayed
sysctlcommand in a terminal
The temporary change lasts until reboot. If Grant access is unavailable, install pkexec through your distribution or use the terminal command. Missing perf or memory-controller events must be resolved through the distribution's Linux tools packages and kernel PMU support.
For manual configuration details, see Performance Counter Access.
Bandwidth measurement requires an Apple Silicon Mac. Mess reads the Apple memory controller through IOReport, so no driver, root access, or Linux counter configuration is required.
Intel Macs do not provide a supported bandwidth backend. If IOReport cannot expose the memory-controller channels on Apple Silicon, use the diagnostic text shown by the GUI when reporting the problem.
Run the GUI as an administrator. Memory-controller access uses a privileged driver, and the benchmark cannot run when the application is not elevated.
The required backend depends on the processor:
| Processor | Recommended backend |
|---|---|
| AMD | AMD uProf |
| Intel Ice Lake / 10th generation or newer | Intel VTune Profiler |
| Older Intel processors | Intel PCM with the msr.sys driver |
The GUI reports specific conditions such as a stopped or outdated msr.sys service, missing VTune drivers, missing AMD uProf, unsupported processors, or counters hidden by Windows virtualization-based security. Follow the message shown in the system panel, then select Recheck system.
See Windows installation for toolchain and backend setup.
- Installation - Install and configure the Mess backend
- Mess Benchmark - Understand the benchmark and its measurements
- Understand output - Interpret files produced by Mess
- Plotter-parser - Generate plots and process measurement data manually
- FAQ - Common questions and known limitations
