In this article, we’ll be benchmarking some of the available RISC‑V single-board computers (SBCs) using CoreMark®. We'll be diving into both single-core and multi-core CPU performance to see how these boards handle real-world compute workloads.
We’ll also walk through the complete setup process for running CoreMark® on RISC‑V hardware — so you can easily replicate the benchmarks on your own system.
1. System & Environment Details
All system, hardware and environment specifications used in this benchmark — including vendor, board name, OS, compiler version, SoC, CPU, cores, RAM, and RISC‑V extensions — are listed in the table below.
2. Setup and Installation
Clone the CoreMark repo. from github/coremark and follow the README.md for more details if you want.
In order to setup follow these steps:
sudo apt update && sudo apt upgrade -y
git clone https://github.com/eembc/coremark.git && cd coremark
make -j$(nproc) OPATH=coremark-st \
XCFLAGS="-DMULTITHREAD=1" \
ITERATIONS=8000 CC=gcc \
PORT_DIR=linux/ RUN=
This should build the Coremark, and binary will be available in `coremark-st/coremark.exe` where `XCFLAGS="-DMULTITHREAD=1"` means this is single core build.
In order to build it for multi-core use this command. This below command build the Coremark for 8 cores.
# NOTE: Change '-DMULTITHREAD=8' as per your core count.
make -j$(nproc) OPATH=coremark-mt/ \
XCFLAGS="-DMULTITHREAD=8 -DUSE_PTHREAD -pthread" \
ITERATIONS=800 CC=gcc \
PORT_DIR=linux/ RUN=
This will place the binary in: `coremark-mt/coremark.exe`
3. Running CPU benchmark
CoreMark is a small, portable CPU benchmark from EEMBC that exercises a representative mix of integer workloads — list processing, simple matrix operations, a small state-machine, and CRC calculations — to characterize the core performance of embedded CPUs. You tell CoreMark how many iterations to perform (call that 𝑁). The program executes the workload loop 𝑁 times and measures how long that takes, then reports a throughput metric typically shown as Iterations/Sec (the number of iterations completed per second).
To get better results we'll run the N Iterations for n times and then take mean of each Iteration. The N and n I choose is listed below.
# Here calling N as ITERATIONS and n as RUNS_PER_ITER
ITERATIONS=(200000 400000 1000000 2000000 4000000 8000000)
RUNS_PER_ITER=5
Let's run the benchmark for all iterations (N). Use this command to start the benchmark.
ITERATIONS=(200000 400000 1000000 2000000 4000000 8000000) && \
RUNS_PER_ITER=5 && \
OUTDIR="coremark_results" && \
mkdir -p "$OUTDIR" && \
for iter in "${ITERATIONS[@]}"; do \
echo "== Running tests for iteration: $iter =="; \
for ((i=1; i<=RUNS_PER_ITER; i++)); do \
OUTFILE="$OUTDIR/coremark_${iter}_run${i}.log"; \
echo " -> Run #$i"; \
./coremark-st/coremark.exe 0x0 0x0 0x66 "$iter" 7 1 2000 > "$OUTFILE"; \
done; \
done
Once complete this generate logs in `coremark_results` directory, now you have to review each file and look for `Iterations/Sec :` and since for all Iteration (N) there are 5 runs (n) you should sum all the `Iterations/Sec :` values and divide that with 5, this should be the final score for that particular iteration — do this for all the iterations.
This is the sample log file that coremark usually generate.
$ cat coremark_results/coremark_8000000_run5.log
2K performance run parameters for coremark.
CoreMark Size : 666
Total ticks : 931599
Total time (secs): 931.599000
Iterations/Sec : 34349.543097 <-- This is the value we need to look at
Iterations : 32000000
Compiler version : GCC14.2.0
Compiler flags : -O2 -DMULTITHREAD=4 -DUSE_PTHREAD -pthread -DPERFORMANCE_RUN=1 -lrt
Parallel PThreads : 4
Memory location : Please put data memory location here
(e.g. code in flash, data on heap etc)
seedcrc : 0xe9f5
[0]crclist : 0xe714
[1]crclist : 0xe714
Correct operation validated. See README.md for run and reporting rules.
CoreMark 1.0 : 34349.543097 / GCC14.2.0 -O2 -DMULTITHREAD=4 -DUSE_PTHREAD -pthread -DPERFORMANCE_RUN=1 -lrt / Heap / 4:PThreads
4. Auto-Setup CoreMark Script for RISCV
You can use this below script which automates building and running the CoreMark benchmark in both single-threaded (ST) and multi-threaded (MT) modes.This script will also read all the logs and give the final Iterations/sec value for each iteration.
5. Benchmark Results & Performance Comparison
To cut the effort I've used the above script and that should give you following results.
5.1 Single Core
Single core results for CoreMark are attached in below.
5.2 Multi Core
To obtain multi-core results, we first need to build CoreMark as described in Section 2.
Since the RISC-V SBCs I’ve chosen have varying numbers of CPU cores, we can’t directly compare raw multi-core performance. To make the results fair, we can compile CoreMark with a fixed thread count — for example, using the -DMULTITHREAD=4 option.
This ensures that every SBC runs the benchmark with the same number of threads, regardless of its maximum core count. For instance, the Milk-V Pioneer has 64 cores, while other boards have far fewer; by standardizing on a lower, common thread count, we get more comparable and fair multi-core performance results. Do try this out and let us know what results you see at cloud-v@10xengineers.io
6. Overall Results and Conclusion
By running each test multiple times and averaging the results, we cut out random noise and get fair, consistent numbers. Looking at those numbers, the Milk-V Pioneer Box clearly leads the pack — even when using just a single core. This shows that performance isn’t just about clock speed; things like smarter pipelines, bigger caches, and modern CPU design matter a lot.