同じARMコア(M33)で複数メーカのRTOS処理速度を比べてみた

Zephyr RTOSでは、デバイスの性能（処理速度や応答速度）を簡単に測定できます。

今回は同じM系コア(M33, M0+)で複数メーカで比較したテスト内容・結果を紹介します。

同じARMコア(M33)で複数メーカのRTOS処理速度を比べてみた
1. ベンチマーク
ARM_M系4機種 Zephyr処理時間比較
まとめ

同じARMコア(M33)で複数メーカのRTOS処理速度を比べてみた

Zephyr RTOSでは、デバイスの性能（処理速度や応答速度）を簡単に測定できます。

今回は同じM系コア(M33, M0+)で複数メーカの比較したテスト内容・結果を紹介します。

前回ラズパイでA系コアとM系コアを比較した結果も下記記事で紹介しています。

RTOSとしての応答速度を比較してみた(Zephyrでのベンチマーク)

RTOSとしての応答速度を比較してみた(Zephyrでのベンチマーク)

Zephyr RTOSでは、デバイスの性能（処理速度や応答速度）を簡単に測定できます。公式ベンチマークテスト(latency_measure)が用意されています。ラズパイ5(A76)、ラズパイ4B(A72)、Pico2W(M33)、Pico...

ベンチマーク

よく見かけるデバイスとしてのスペック比較のCoremarkベンチマークもあります。

ただ今回使用したZephyr(RTOS)のベンチマークは、下記のlatency_measureを使いました。

RTOSとしての比較・ベンチマークしてみたいと思ったためです。

zephyr/tests/benchmarks/latency_measure at main · zephyrproject-rtos/zephyr

Primary Git Repository for the Zephyr Project. Zephyr is a new generation, scalable, optimized, secure RTOS for multiple...

ARM_M系4機種 Zephyr処理時間比較

※ 数値が小さいほど高速です。単位はnsです。

項目	RW612(M33 / 260MHz)	Pico 2 W(M33 / 150MHz)	nRF54L15(M33 / 128MHz)	Pico(M0+ / 125MHz)
Context Switch(スレッド切替)	699	1,145	1,376	2,165
Mutex Lock(排他制御)	286	471	556	740
Semaphore Take(待機あり取得)	1,089	1,794	2,219	3,205
Heap Malloc(メモリ確保)	2,017	4,199	2,254	8,830
Thread Create(スレッド作成)	1,061	1,481	2,265	2,870

この表からのハイライト:

高クロックほど処理速度は速い:
RW612がすべての項目でトップです。高クロック(260MHz)の強さがそのまま出ています。
Mallocにおける nRF54L15 の逆転:
CPU性能では Pico 2 W の方が上ですが、Heap Malloc だけは nRF54L15 が 約2倍高速 です（2,254ns vs 4,199ns）。これは外部フラッシュ(XIP)へのアクセス遅延がないためと考えられます。チップ内蔵の不揮発性メモリRRAM (ReRAM) の効果が出ています。
世代交代の完了:
初代Pico (M0+) と比較して、M33搭載の3機種（RW612, Pico 2 W, nRF）は、基本性能で 2倍〜3倍 の速度差をつけています。

各ベンチマークした結果を貼り付けておきます。

NXP FRDM-RW612(M33)

west build -p always -b frdm_rw612 tests/benchmarks/latency_measure

*** Booting Zephyr OS build v4.3.0-3034-g2062a21ed267 ***
thread.yield.preemptive.ctx.k_to_k       - Context switch via k_yield                         :     181 cycles ,      699 ns : 
thread.yield.cooperative.ctx.k_to_k      - Context switch via k_yield                         :     181 cycles ,      697 ns : 
isr.resume.interrupted.thread.kernel     - Return from ISR to interrupted thread              :     170 cycles ,      655 ns : 
isr.resume.different.thread.kernel       - Return from ISR to another thread                  :     215 cycles ,      830 ns : 
thread.create.kernel.from.kernel         - Create thread                                      :     275 cycles ,     1061 ns : 
thread.start.kernel.from.kernel          - Start thread                                       :     279 cycles ,     1074 ns : 
thread.suspend.kernel.from.kernel        - Suspend thread                                     :     172 cycles ,      662 ns : 
thread.resume.kernel.from.kernel         - Resume thread                                      :     208 cycles ,      801 ns : 
thread.abort.kernel.from.kernel          - Abort thread                                       :     182 cycles ,      700 ns : 
fifo.put.immediate.kernel                - Add data to FIFO (no ctx switch)                   :     105 cycles ,      404 ns : 
fifo.get.immediate.kernel                - Get data from FIFO (no ctx switch)                 :      84 cycles ,      325 ns : 
fifo.put.alloc.immediate.kernel          - Allocate to add data to FIFO (no ctx switch)       :     667 cycles ,     2568 ns : 
fifo.get.free.immediate.kernel           - Free when getting data from FIFO (no ctx switch)   :     674 cycles ,     2595 ns : 
fifo.get.blocking.k_to_k                 - Get data from FIFO (w/ ctx switch)                 :     312 cycles ,     1203 ns : 
fifo.put.wake+ctx.k_to_k                 - Add data to FIFO (w/ ctx switch)                   :     361 cycles ,     1390 ns : 
fifo.get.free.blocking.k_to_k            - Free when getting data from FIFO (w/ ctx switch)   :     313 cycles ,     1203 ns : 
fifo.put.alloc.wake+ctx.k_to_k           - Allocate to add data to FIFO (w/ ctx switch)       :     360 cycles ,     1384 ns : 
lifo.put.immediate.kernel                - Add data to LIFO (no ctx switch)                   :     102 cycles ,      396 ns : 
lifo.get.immediate.kernel                - Get data from LIFO (no ctx switch)                 :      83 cycles ,      323 ns : 
lifo.put.alloc.immediate.kernel          - Allocate to add data to LIFO (no ctx switch)       :     662 cycles ,     2549 ns : 
lifo.get.free.immediate.kernel           - Free when getting data from LIFO (no ctx switch)   :     672 cycles ,     2584 ns : 
lifo.get.blocking.k_to_k                 - Get data from LIFO (w/ ctx switch)                 :     312 cycles ,     1203 ns : 
lifo.put.wake+ctx.k_to_k                 - Add data to LIFO (w/ ctx switch)                   :     360 cycles ,     1384 ns : 
lifo.get.free.blocking.k_to_k            - Free when getting data from LIFO (w/ ctx switch)   :     313 cycles ,     1203 ns : 
lifo.put.alloc.wake+ctx.k_to_k           - Allocate to add data to LIFO (w/ ctx switch)       :     360 cycles ,     1384 ns : 
events.post.immediate.kernel             - Post events (nothing wakes)                        :     149 cycles ,      573 ns : 
events.set.immediate.kernel              - Set events (nothing wakes)                         :     148 cycles ,      569 ns : 
events.wait.immediate.kernel             - Wait for any events (no ctx switch)                :      94 cycles ,      362 ns : 
events.wait_all.immediate.kernel         - Wait for all events (no ctx switch)                :      93 cycles ,      357 ns : 
events.wait.blocking.k_to_k              - Wait for any events (w/ ctx switch)                :     328 cycles ,     1263 ns : 
events.set.wake+ctx.k_to_k               - Set events (w/ ctx switch)                         :     478 cycles ,     1840 ns : 
events.wait_all.blocking.k_to_k          - Wait for all events (w/ ctx switch)                :     346 cycles ,     1333 ns : 
events.post.wake+ctx.k_to_k              - Post events (w/ ctx switch)                        :     489 cycles ,     1880 ns : 
semaphore.give.immediate.kernel          - Give a semaphore (no waiters)                      :      54 cycles ,      209 ns : 
semaphore.take.immediate.kernel          - Take a semaphore (no blocking)                     :      61 cycles ,      235 ns : 
semaphore.take.blocking.k_to_k           - Take a semaphore (context switch)                  :     283 cycles ,     1089 ns : 
semaphore.give.wake+ctx.k_to_k           - Give a semaphore (context switch)                  :     310 cycles ,     1193 ns : 
condvar.wait.blocking.k_to_k             - Wait for a condvar (context switch)                :     371 cycles ,     1428 ns : 
condvar.signal.wake+ctx.k_to_k           - Signal a condvar (context switch)                  :     385 cycles ,     1483 ns : 
stack.push.immediate.kernel              - Add data to k_stack (no ctx switch)                :      62 cycles ,      240 ns : 
stack.pop.immediate.kernel               - Get data from k_stack (no ctx switch)              :      67 cycles ,      259 ns : 
stack.pop.blocking.k_to_k                - Get data from k_stack (w/ ctx switch)              :     306 cycles ,     1177 ns : 
stack.push.wake+ctx.k_to_k               - Add data to k_stack (w/ ctx switch)                :     337 cycles ,     1296 ns : 
mutex.lock.immediate.recursive.kernel    - Lock a mutex                                       :      74 cycles ,      286 ns : 
mutex.unlock.immediate.recursive.kernel  - Unlock a mutex                                     :      38 cycles ,      147 ns : 
heap.malloc.immediate                    - Average time for heap malloc                       :     524 cycles ,     2017 ns : 
heap.free.immediate                      - Average time for heap free                         :     587 cycles ,     2258 ns : 
===================================================================
PROJECT EXECUTION SUCCESSFUL

*** Booting Zephyr OS build v4.3.0-3034-g2062a21ed267 ***

thread.yield.preemptive.ctx.k_to_k - Context switch via k_yield : 181 cycles , 699 ns :

thread.yield.cooperative.ctx.k_to_k - Context switch via k_yield : 181 cycles , 697 ns :

isr.resume.interrupted.thread.kernel - Return from ISR to interrupted thread : 170 cycles , 655 ns :

isr.resume.different.thread.kernel - Return from ISR to another thread : 215 cycles , 830 ns :

thread.create.kernel.from.kernel - Create thread : 275 cycles , 1061 ns :

thread.start.kernel.from.kernel - Start thread : 279 cycles , 1074 ns :

thread.suspend.kernel.from.kernel - Suspend thread : 172 cycles , 662 ns :

thread.resume.kernel.from.kernel - Resume thread : 208 cycles , 801 ns :

thread.abort.kernel.from.kernel - Abort thread : 182 cycles , 700 ns :

fifo.put.immediate.kernel - Add data to FIFO (no ctx switch) : 105 cycles , 404 ns :

fifo.get.immediate.kernel - Get data from FIFO (no ctx switch) : 84 cycles , 325 ns :

fifo.put.alloc.immediate.kernel - Allocate to add data to FIFO (no ctx switch) : 667 cycles , 2568 ns :

fifo.get.free.immediate.kernel - Free when getting data from FIFO (no ctx switch) : 674 cycles , 2595 ns :

fifo.get.blocking.k_to_k - Get data from FIFO (w/ ctx switch) : 312 cycles , 1203 ns :

fifo.put.wake+ctx.k_to_k - Add data to FIFO (w/ ctx switch) : 361 cycles , 1390 ns :

fifo.get.free.blocking.k_to_k - Free when getting data from FIFO (w/ ctx switch) : 313 cycles , 1203 ns :

fifo.put.alloc.wake+ctx.k_to_k - Allocate to add data to FIFO (w/ ctx switch) : 360 cycles , 1384 ns :

lifo.put.immediate.kernel - Add data to LIFO (no ctx switch) : 102 cycles , 396 ns :

lifo.get.immediate.kernel - Get data from LIFO (no ctx switch) : 83 cycles , 323 ns :

lifo.put.alloc.immediate.kernel - Allocate to add data to LIFO (no ctx switch) : 662 cycles , 2549 ns :

lifo.get.free.immediate.kernel - Free when getting data from LIFO (no ctx switch) : 672 cycles , 2584 ns :

lifo.get.blocking.k_to_k - Get data from LIFO (w/ ctx switch) : 312 cycles , 1203 ns :

lifo.put.wake+ctx.k_to_k - Add data to LIFO (w/ ctx switch) : 360 cycles , 1384 ns :

lifo.get.free.blocking.k_to_k - Free when getting data from LIFO (w/ ctx switch) : 313 cycles , 1203 ns :

lifo.put.alloc.wake+ctx.k_to_k - Allocate to add data to LIFO (w/ ctx switch) : 360 cycles , 1384 ns :

events.post.immediate.kernel - Post events (nothing wakes) : 149 cycles , 573 ns :

events.set.immediate.kernel - Set events (nothing wakes) : 148 cycles , 569 ns :

events.wait.immediate.kernel - Wait for any events (no ctx switch) : 94 cycles , 362 ns :

events.wait_all.immediate.kernel - Wait for all events (no ctx switch) : 93 cycles , 357 ns :

events.wait.blocking.k_to_k - Wait for any events (w/ ctx switch) : 328 cycles , 1263 ns :

events.set.wake+ctx.k_to_k - Set events (w/ ctx switch) : 478 cycles , 1840 ns :

events.wait_all.blocking.k_to_k - Wait for all events (w/ ctx switch) : 346 cycles , 1333 ns :

events.post.wake+ctx.k_to_k - Post events (w/ ctx switch) : 489 cycles , 1880 ns :

semaphore.give.immediate.kernel - Give a semaphore (no waiters) : 54 cycles , 209 ns :

semaphore.take.immediate.kernel - Take a semaphore (no blocking) : 61 cycles , 235 ns :

semaphore.take.blocking.k_to_k - Take a semaphore (context switch) : 283 cycles , 1089 ns :

semaphore.give.wake+ctx.k_to_k - Give a semaphore (context switch) : 310 cycles , 1193 ns :

condvar.wait.blocking.k_to_k - Wait for a condvar (context switch) : 371 cycles , 1428 ns :

condvar.signal.wake+ctx.k_to_k - Signal a condvar (context switch) : 385 cycles , 1483 ns :

stack.push.immediate.kernel - Add data to k_stack (no ctx switch) : 62 cycles , 240 ns :

stack.pop.immediate.kernel - Get data from k_stack (no ctx switch) : 67 cycles , 259 ns :

stack.pop.blocking.k_to_k - Get data from k_stack (w/ ctx switch) : 306 cycles , 1177 ns :

stack.push.wake+ctx.k_to_k - Add data to k_stack (w/ ctx switch) : 337 cycles , 1296 ns :

mutex.lock.immediate.recursive.kernel - Lock a mutex : 74 cycles , 286 ns :

mutex.unlock.immediate.recursive.kernel - Unlock a mutex : 38 cycles , 147 ns :

heap.malloc.immediate - Average time for heap malloc : 524 cycles , 2017 ns :

heap.free.immediate - Average time for heap free : 587 cycles , 2258 ns :

===================================================================

PROJECT EXECUTION SUCCESSFUL

RaspberryPi Pico2W(M33)

west build -p always -b rpi_pico2/rp2350a/m33/w tests/benchmarks/latency_measure

*** Booting Zephyr OS build v4.3.0-rc3 ***
thread.yield.preemptive.ctx.k_to_k       - Context switch via k_yield                         :     171 cycles ,     1145 ns :
thread.yield.cooperative.ctx.k_to_k      - Context switch via k_yield                         :     170 cycles ,     1137 ns :
isr.resume.interrupted.thread.kernel     - Return from ISR to interrupted thread              :     434 cycles ,     2897 ns :
isr.resume.different.thread.kernel       - Return from ISR to another thread                  :     480 cycles ,     3203 ns :
thread.create.kernel.from.kernel         - Create thread                                      :     222 cycles ,     1481 ns :
thread.start.kernel.from.kernel          - Start thread                                       :     263 cycles ,     1754 ns :
thread.suspend.kernel.from.kernel        - Suspend thread                                     :     161 cycles ,     1074 ns :
thread.resume.kernel.from.kernel         - Resume thread                                      :     194 cycles ,     1299 ns :
thread.abort.kernel.from.kernel          - Abort thread                                       :     177 cycles ,     1182 ns :
fifo.put.immediate.kernel                - Add data to FIFO (no ctx switch)                   :     102 cycles ,      685 ns :
fifo.get.immediate.kernel                - Get data from FIFO (no ctx switch)                 :      84 cycles ,      560 ns :
fifo.put.alloc.immediate.kernel          - Allocate to add data to FIFO (no ctx switch)       :     719 cycles ,     4795 ns :
fifo.get.free.immediate.kernel           - Free when getting data from FIFO (no ctx switch)   :     725 cycles ,     4835 ns :
fifo.get.blocking.k_to_k                 - Get data from FIFO (w/ ctx switch)                 :     363 cycles ,     2423 ns :
fifo.put.wake+ctx.k_to_k                 - Add data to FIFO (w/ ctx switch)                   :     408 cycles ,     2726 ns :
fifo.get.free.blocking.k_to_k            - Free when getting data from FIFO (w/ ctx switch)   :     362 cycles ,     2418 ns :
fifo.put.alloc.wake+ctx.k_to_k           - Allocate to add data to FIFO (w/ ctx switch)       :     406 cycles ,     2709 ns :
lifo.put.immediate.kernel                - Add data to LIFO (no ctx switch)                   :     101 cycles ,      673 ns :
lifo.get.immediate.kernel                - Get data from LIFO (no ctx switch)                 :      83 cycles ,      556 ns :
lifo.put.alloc.immediate.kernel          - Allocate to add data to LIFO (no ctx switch)       :     714 cycles ,     4762 ns :
lifo.get.free.immediate.kernel           - Free when getting data from LIFO (no ctx switch)   :     721 cycles ,     4811 ns :
lifo.get.blocking.k_to_k                 - Get data from LIFO (w/ ctx switch)                 :     363 cycles ,     2420 ns :
lifo.put.wake+ctx.k_to_k                 - Add data to LIFO (w/ ctx switch)                   :     406 cycles ,     2708 ns :
lifo.get.free.blocking.k_to_k            - Free when getting data from LIFO (w/ ctx switch)   :     362 cycles ,     2415 ns :
lifo.put.alloc.wake+ctx.k_to_k           - Allocate to add data to LIFO (w/ ctx switch)       :     406 cycles ,     2707 ns :
events.post.immediate.kernel             - Post events (nothing wakes)                        :     146 cycles ,      978 ns :
events.set.immediate.kernel              - Set events (nothing wakes)                         :     146 cycles ,      977 ns :
events.wait.immediate.kernel             - Wait for any events (no ctx switch)                :      92 cycles ,      617 ns :
events.wait_all.immediate.kernel         - Wait for all events (no ctx switch)                :      91 cycles ,      610 ns :
events.wait.blocking.k_to_k              - Wait for any events (w/ ctx switch)                :     310 cycles ,     2068 ns :
events.set.wake+ctx.k_to_k               - Set events (w/ ctx switch)                         :     458 cycles ,     3054 ns :
events.wait_all.blocking.k_to_k          - Wait for all events (w/ ctx switch)                :     392 cycles ,     2615 ns :
events.post.wake+ctx.k_to_k              - Post events (w/ ctx switch)                        :     531 cycles ,     3541 ns :
semaphore.give.immediate.kernel          - Give a semaphore (no waiters)                      :      52 cycles ,      352 ns :
semaphore.take.immediate.kernel          - Take a semaphore (no blocking)                     :      61 cycles ,      410 ns :
semaphore.take.blocking.k_to_k           - Take a semaphore (context switch)                  :     269 cycles ,     1794 ns :
semaphore.give.wake+ctx.k_to_k           - Give a semaphore (context switch)                  :     291 cycles ,     1940 ns :
condvar.wait.blocking.k_to_k             - Wait for a condvar (context switch)                :     420 cycles ,     2801 ns :
condvar.signal.wake+ctx.k_to_k           - Signal a condvar (context switch)                  :     434 cycles ,     2895 ns :
stack.push.immediate.kernel              - Add data to k_stack (no ctx switch)                :      60 cycles ,      406 ns :
stack.pop.immediate.kernel               - Get data from k_stack (no ctx switch)              :      64 cycles ,      432 ns :
stack.pop.blocking.k_to_k                - Get data from k_stack (w/ ctx switch)              :     357 cycles ,     2380 ns :
stack.push.wake+ctx.k_to_k               - Add data to k_stack (w/ ctx switch)                :     385 cycles ,     2570 ns :
mutex.lock.immediate.recursive.kernel    - Lock a mutex                                       :      70 cycles ,      471 ns :
mutex.unlock.immediate.recursive.kernel  - Unlock a mutex                                     :      37 cycles ,      248 ns :
heap.malloc.immediate                    - Average time for heap malloc                       :     629 cycles ,     4199 ns :
heap.free.immediate                      - Average time for heap free                         :     664 cycles ,     4430 ns :
===================================================================
PROJECT EXECUTION SUCCESSFUL

*** Booting Zephyr OS build v4.3.0-rc3 ***

thread.yield.preemptive.ctx.k_to_k - Context switch via k_yield : 171 cycles , 1145 ns :

thread.yield.cooperative.ctx.k_to_k - Context switch via k_yield : 170 cycles , 1137 ns :

isr.resume.interrupted.thread.kernel - Return from ISR to interrupted thread : 434 cycles , 2897 ns :

isr.resume.different.thread.kernel - Return from ISR to another thread : 480 cycles , 3203 ns :

thread.create.kernel.from.kernel - Create thread : 222 cycles , 1481 ns :

thread.start.kernel.from.kernel - Start thread : 263 cycles , 1754 ns :

thread.suspend.kernel.from.kernel - Suspend thread : 161 cycles , 1074 ns :

thread.resume.kernel.from.kernel - Resume thread : 194 cycles , 1299 ns :

thread.abort.kernel.from.kernel - Abort thread : 177 cycles , 1182 ns :

fifo.put.immediate.kernel - Add data to FIFO (no ctx switch) : 102 cycles , 685 ns :

fifo.get.immediate.kernel - Get data from FIFO (no ctx switch) : 84 cycles , 560 ns :

fifo.put.alloc.immediate.kernel - Allocate to add data to FIFO (no ctx switch) : 719 cycles , 4795 ns :

fifo.get.free.immediate.kernel - Free when getting data from FIFO (no ctx switch) : 725 cycles , 4835 ns :

fifo.get.blocking.k_to_k - Get data from FIFO (w/ ctx switch) : 363 cycles , 2423 ns :

fifo.put.wake+ctx.k_to_k - Add data to FIFO (w/ ctx switch) : 408 cycles , 2726 ns :

fifo.get.free.blocking.k_to_k - Free when getting data from FIFO (w/ ctx switch) : 362 cycles , 2418 ns :

fifo.put.alloc.wake+ctx.k_to_k - Allocate to add data to FIFO (w/ ctx switch) : 406 cycles , 2709 ns :

lifo.put.immediate.kernel - Add data to LIFO (no ctx switch) : 101 cycles , 673 ns :

lifo.get.immediate.kernel - Get data from LIFO (no ctx switch) : 83 cycles , 556 ns :

lifo.put.alloc.immediate.kernel - Allocate to add data to LIFO (no ctx switch) : 714 cycles , 4762 ns :

lifo.get.free.immediate.kernel - Free when getting data from LIFO (no ctx switch) : 721 cycles , 4811 ns :

lifo.get.blocking.k_to_k - Get data from LIFO (w/ ctx switch) : 363 cycles , 2420 ns :

lifo.put.wake+ctx.k_to_k - Add data to LIFO (w/ ctx switch) : 406 cycles , 2708 ns :

lifo.get.free.blocking.k_to_k - Free when getting data from LIFO (w/ ctx switch) : 362 cycles , 2415 ns :

lifo.put.alloc.wake+ctx.k_to_k - Allocate to add data to LIFO (w/ ctx switch) : 406 cycles , 2707 ns :

events.post.immediate.kernel - Post events (nothing wakes) : 146 cycles , 978 ns :

events.set.immediate.kernel - Set events (nothing wakes) : 146 cycles , 977 ns :

events.wait.immediate.kernel - Wait for any events (no ctx switch) : 92 cycles , 617 ns :

events.wait_all.immediate.kernel - Wait for all events (no ctx switch) : 91 cycles , 610 ns :

events.wait.blocking.k_to_k - Wait for any events (w/ ctx switch) : 310 cycles , 2068 ns :

events.set.wake+ctx.k_to_k - Set events (w/ ctx switch) : 458 cycles , 3054 ns :

events.wait_all.blocking.k_to_k - Wait for all events (w/ ctx switch) : 392 cycles , 2615 ns :

events.post.wake+ctx.k_to_k - Post events (w/ ctx switch) : 531 cycles , 3541 ns :

semaphore.give.immediate.kernel - Give a semaphore (no waiters) : 52 cycles , 352 ns :

semaphore.take.immediate.kernel - Take a semaphore (no blocking) : 61 cycles , 410 ns :

semaphore.take.blocking.k_to_k - Take a semaphore (context switch) : 269 cycles , 1794 ns :

semaphore.give.wake+ctx.k_to_k - Give a semaphore (context switch) : 291 cycles , 1940 ns :

condvar.wait.blocking.k_to_k - Wait for a condvar (context switch) : 420 cycles , 2801 ns :

condvar.signal.wake+ctx.k_to_k - Signal a condvar (context switch) : 434 cycles , 2895 ns :

stack.push.immediate.kernel - Add data to k_stack (no ctx switch) : 60 cycles , 406 ns :

stack.pop.immediate.kernel - Get data from k_stack (no ctx switch) : 64 cycles , 432 ns :

stack.pop.blocking.k_to_k - Get data from k_stack (w/ ctx switch) : 357 cycles , 2380 ns :

stack.push.wake+ctx.k_to_k - Add data to k_stack (w/ ctx switch) : 385 cycles , 2570 ns :

mutex.lock.immediate.recursive.kernel - Lock a mutex : 70 cycles , 471 ns :

mutex.unlock.immediate.recursive.kernel - Unlock a mutex : 37 cycles , 248 ns :

heap.malloc.immediate - Average time for heap malloc : 629 cycles , 4199 ns :

heap.free.immediate - Average time for heap free : 664 cycles , 4430 ns :

===================================================================

PROJECT EXECUTION SUCCESSFUL

Nordic nRF54L15DK(M33)

west build -p always -b nrf54l15dk/nrf54l15/cpuapp tests/benchmarks/latency_measure

*** Booting nRF Connect SDK v3.2.1-d8887f6f32df ***
*** Using Zephyr OS v4.2.99-ec78104f1569 ***
thread.yield.preemptive.ctx.k_to_k       - Context switch via k_yield                         :     176 cycles ,     1376 ns : 
thread.yield.cooperative.ctx.k_to_k      - Context switch via k_yield                         :     176 cycles ,     1375 ns : 
isr.resume.interrupted.thread.kernel     - Return from ISR to interrupted thread              : 4294956 cycles , 33554345 ns : 
isr.resume.different.thread.kernel       - Return from ISR to another thread                  : 4294956 cycles , 33554345 ns : 
thread.create.kernel.from.kernel         - Create thread                                      :     290 cycles ,     2265 ns : 
thread.start.kernel.from.kernel          - Start thread                                       :     301 cycles ,     2359 ns : 
thread.suspend.kernel.from.kernel        - Suspend thread                                     :     182 cycles ,     1422 ns : 
thread.resume.kernel.from.kernel         - Resume thread                                      :     206 cycles ,     1609 ns : 
thread.abort.kernel.from.kernel          - Abort thread                                       :     245 cycles ,     1914 ns : 
fifo.put.immediate.kernel                - Add data to FIFO (no ctx switch)                   :     102 cycles ,      798 ns : 
fifo.get.immediate.kernel                - Get data from FIFO (no ctx switch)                 :      83 cycles ,      649 ns : 
fifo.put.alloc.immediate.kernel          - Allocate to add data to FIFO (no ctx switch)       :     430 cycles ,     3362 ns : 
fifo.get.free.immediate.kernel           - Free when getting data from FIFO (no ctx switch)   :     364 cycles ,     2846 ns : 
fifo.get.blocking.k_to_k                 - Get data from FIFO (w/ ctx switch)                 :     310 cycles ,     2422 ns : 
fifo.put.wake+ctx.k_to_k                 - Add data to FIFO (w/ ctx switch)                   :     351 cycles ,     2742 ns : 
fifo.get.free.blocking.k_to_k            - Free when getting data from FIFO (w/ ctx switch)   :     309 cycles ,     2414 ns : 
fifo.put.alloc.wake+ctx.k_to_k           - Allocate to add data to FIFO (w/ ctx switch)       :     349 cycles ,     2726 ns : 
lifo.put.immediate.kernel                - Add data to LIFO (no ctx switch)                   :     101 cycles ,      790 ns : 
lifo.get.immediate.kernel                - Get data from LIFO (no ctx switch)                 :      83 cycles ,      648 ns : 
lifo.put.alloc.immediate.kernel          - Allocate to add data to LIFO (no ctx switch)       :     430 cycles ,     3361 ns : 
lifo.get.free.immediate.kernel           - Free when getting data from LIFO (no ctx switch)   :     364 cycles ,     2844 ns : 
lifo.get.blocking.k_to_k                 - Get data from LIFO (w/ ctx switch)                 :     308 cycles ,     2406 ns : 
lifo.put.wake+ctx.k_to_k                 - Add data to LIFO (w/ ctx switch)                   :     349 cycles ,     2727 ns : 
lifo.get.free.blocking.k_to_k            - Free when getting data from LIFO (w/ ctx switch)   :     308 cycles ,     2406 ns : 
lifo.put.alloc.wake+ctx.k_to_k           - Allocate to add data to LIFO (w/ ctx switch)       :     350 cycles ,     2734 ns : 
events.post.immediate.kernel             - Post events (nothing wakes)                        :     145 cycles ,     1133 ns : 
events.set.immediate.kernel              - Set events (nothing wakes)                         :     146 cycles ,     1141 ns : 
events.wait.immediate.kernel             - Wait for any events (no ctx switch)                :      93 cycles ,      727 ns : 
events.wait_all.immediate.kernel         - Wait for all events (no ctx switch)                :      91 cycles ,      711 ns : 
events.wait.blocking.k_to_k              - Wait for any events (w/ ctx switch)                :     346 cycles ,     2703 ns : 
events.set.wake+ctx.k_to_k               - Set events (w/ ctx switch)                         :     556 cycles ,     4344 ns : 
events.wait_all.blocking.k_to_k          - Wait for all events (w/ ctx switch)                :     346 cycles ,     2703 ns : 
events.post.wake+ctx.k_to_k              - Post events (w/ ctx switch)                        :     513 cycles ,     4008 ns : 
semaphore.give.immediate.kernel          - Give a semaphore (no waiters)                      :      52 cycles ,      407 ns : 
semaphore.take.immediate.kernel          - Take a semaphore (no blocking)                     :      62 cycles ,      485 ns : 
semaphore.take.blocking.k_to_k           - Take a semaphore (context switch)                  :     284 cycles ,     2219 ns : 
semaphore.give.wake+ctx.k_to_k           - Give a semaphore (context switch)                  :     304 cycles ,     2375 ns : 
condvar.wait.blocking.k_to_k             - Wait for a condvar (context switch)                :     368 cycles ,     2877 ns : 
condvar.signal.wake+ctx.k_to_k           - Signal a condvar (context switch)                  :     421 cycles ,     3289 ns : 
stack.push.immediate.kernel              - Add data to k_stack (no ctx switch)                :      63 cycles ,      492 ns : 
stack.pop.immediate.kernel               - Get data from k_stack (no ctx switch)              :      65 cycles ,      508 ns : 
stack.pop.blocking.k_to_k                - Get data from k_stack (w/ ctx switch)              :     305 cycles ,     2383 ns : 
stack.push.wake+ctx.k_to_k               - Add data to k_stack (w/ ctx switch)                :     336 cycles ,     2625 ns : 
mutex.lock.immediate.recursive.kernel    - Lock a mutex                                       :      71 cycles ,      556 ns : 
mutex.unlock.immediate.recursive.kernel  - Unlock a mutex                                     :      39 cycles ,      306 ns : 
heap.malloc.immediate                    - Average time for heap malloc                       :     288 cycles ,     2254 ns : 
heap.free.immediate                      - Average time for heap free                         :     283 cycles ,     2211 ns : 
===================================================================
PROJECT EXECUTION SUCCESSFUL

*** Booting nRF Connect SDK v3.2.1-d8887f6f32df ***

*** Using Zephyr OS v4.2.99-ec78104f1569 ***

thread.yield.preemptive.ctx.k_to_k - Context switch via k_yield : 176 cycles , 1376 ns :

thread.yield.cooperative.ctx.k_to_k - Context switch via k_yield : 176 cycles , 1375 ns :

isr.resume.interrupted.thread.kernel - Return from ISR to interrupted thread : 4294956 cycles , 33554345 ns :

isr.resume.different.thread.kernel - Return from ISR to another thread : 4294956 cycles , 33554345 ns :

thread.create.kernel.from.kernel - Create thread : 290 cycles , 2265 ns :

thread.start.kernel.from.kernel - Start thread : 301 cycles , 2359 ns :

thread.suspend.kernel.from.kernel - Suspend thread : 182 cycles , 1422 ns :

thread.resume.kernel.from.kernel - Resume thread : 206 cycles , 1609 ns :

thread.abort.kernel.from.kernel - Abort thread : 245 cycles , 1914 ns :

fifo.put.immediate.kernel - Add data to FIFO (no ctx switch) : 102 cycles , 798 ns :

fifo.get.immediate.kernel - Get data from FIFO (no ctx switch) : 83 cycles , 649 ns :

fifo.put.alloc.immediate.kernel - Allocate to add data to FIFO (no ctx switch) : 430 cycles , 3362 ns :

fifo.get.free.immediate.kernel - Free when getting data from FIFO (no ctx switch) : 364 cycles , 2846 ns :

fifo.get.blocking.k_to_k - Get data from FIFO (w/ ctx switch) : 310 cycles , 2422 ns :

fifo.put.wake+ctx.k_to_k - Add data to FIFO (w/ ctx switch) : 351 cycles , 2742 ns :

fifo.get.free.blocking.k_to_k - Free when getting data from FIFO (w/ ctx switch) : 309 cycles , 2414 ns :

fifo.put.alloc.wake+ctx.k_to_k - Allocate to add data to FIFO (w/ ctx switch) : 349 cycles , 2726 ns :

lifo.put.immediate.kernel - Add data to LIFO (no ctx switch) : 101 cycles , 790 ns :

lifo.get.immediate.kernel - Get data from LIFO (no ctx switch) : 83 cycles , 648 ns :

lifo.put.alloc.immediate.kernel - Allocate to add data to LIFO (no ctx switch) : 430 cycles , 3361 ns :

lifo.get.free.immediate.kernel - Free when getting data from LIFO (no ctx switch) : 364 cycles , 2844 ns :

lifo.get.blocking.k_to_k - Get data from LIFO (w/ ctx switch) : 308 cycles , 2406 ns :

lifo.put.wake+ctx.k_to_k - Add data to LIFO (w/ ctx switch) : 349 cycles , 2727 ns :

lifo.get.free.blocking.k_to_k - Free when getting data from LIFO (w/ ctx switch) : 308 cycles , 2406 ns :

lifo.put.alloc.wake+ctx.k_to_k - Allocate to add data to LIFO (w/ ctx switch) : 350 cycles , 2734 ns :

events.post.immediate.kernel - Post events (nothing wakes) : 145 cycles , 1133 ns :

events.set.immediate.kernel - Set events (nothing wakes) : 146 cycles , 1141 ns :

events.wait.immediate.kernel - Wait for any events (no ctx switch) : 93 cycles , 727 ns :

events.wait_all.immediate.kernel - Wait for all events (no ctx switch) : 91 cycles , 711 ns :

events.wait.blocking.k_to_k - Wait for any events (w/ ctx switch) : 346 cycles , 2703 ns :

events.set.wake+ctx.k_to_k - Set events (w/ ctx switch) : 556 cycles , 4344 ns :

events.wait_all.blocking.k_to_k - Wait for all events (w/ ctx switch) : 346 cycles , 2703 ns :

events.post.wake+ctx.k_to_k - Post events (w/ ctx switch) : 513 cycles , 4008 ns :

semaphore.give.immediate.kernel - Give a semaphore (no waiters) : 52 cycles , 407 ns :

semaphore.take.immediate.kernel - Take a semaphore (no blocking) : 62 cycles , 485 ns :

semaphore.take.blocking.k_to_k - Take a semaphore (context switch) : 284 cycles , 2219 ns :

semaphore.give.wake+ctx.k_to_k - Give a semaphore (context switch) : 304 cycles , 2375 ns :

condvar.wait.blocking.k_to_k - Wait for a condvar (context switch) : 368 cycles , 2877 ns :

condvar.signal.wake+ctx.k_to_k - Signal a condvar (context switch) : 421 cycles , 3289 ns :

stack.push.immediate.kernel - Add data to k_stack (no ctx switch) : 63 cycles , 492 ns :

stack.pop.immediate.kernel - Get data from k_stack (no ctx switch) : 65 cycles , 508 ns :

stack.pop.blocking.k_to_k - Get data from k_stack (w/ ctx switch) : 305 cycles , 2383 ns :

stack.push.wake+ctx.k_to_k - Add data to k_stack (w/ ctx switch) : 336 cycles , 2625 ns :

mutex.lock.immediate.recursive.kernel - Lock a mutex : 71 cycles , 556 ns :

mutex.unlock.immediate.recursive.kernel - Unlock a mutex : 39 cycles , 306 ns :

heap.malloc.immediate - Average time for heap malloc : 288 cycles , 2254 ns :

heap.free.immediate - Average time for heap free : 283 cycles , 2211 ns :

===================================================================

PROJECT EXECUTION SUCCESSFUL

RaspberryPi Pico(M0+)

west build -p always -b rpi_pico tests/benchmarks/latency_measure

*** Booting Zephyr OS build v4.3.0-rc3 ***
thread.yield.preemptive.ctx.k_to_k       - Context switch via k_yield                         :     270 cycles ,     2165 ns :
thread.yield.cooperative.ctx.k_to_k      - Context switch via k_yield                         :     267 cycles ,     2142 ns :
isr.resume.interrupted.thread.kernel     - Return from ISR to interrupted thread              :     696 cycles ,     5573 ns :
isr.resume.different.thread.kernel       - Return from ISR to another thread                  :    1656 cycles ,    13248 ns :
thread.create.kernel.from.kernel         - Create thread                                      :     358 cycles ,     2870 ns :
thread.start.kernel.from.kernel          - Start thread                                       :     683 cycles ,     5465 ns :
thread.suspend.kernel.from.kernel        - Suspend thread                                     :     339 cycles ,     2715 ns :
thread.resume.kernel.from.kernel         - Resume thread                                      :     334 cycles ,     2679 ns :
thread.abort.kernel.from.kernel          - Abort thread                                       :     236 cycles ,     1895 ns :
fifo.put.immediate.kernel                - Add data to FIFO (no ctx switch)                   :     156 cycles ,     1248 ns :
fifo.get.immediate.kernel                - Get data from FIFO (no ctx switch)                 :     114 cycles ,      915 ns :
fifo.put.alloc.immediate.kernel          - Allocate to add data to FIFO (no ctx switch)       :    1163 cycles ,     9310 ns :
fifo.get.free.immediate.kernel           - Free when getting data from FIFO (no ctx switch)   :    1130 cycles ,     9045 ns :
fifo.get.blocking.k_to_k                 - Get data from FIFO (w/ ctx switch)                 :  235406 cycles ,  1883250 ns :
fifo.put.wake+ctx.k_to_k                 - Add data to FIFO (w/ ctx switch)                   :     611 cycles ,     4889 ns :
fifo.get.free.blocking.k_to_k            - Free when getting data from FIFO (w/ ctx switch)   :     523 cycles ,     4189 ns :
fifo.put.alloc.wake+ctx.k_to_k           - Allocate to add data to FIFO (w/ ctx switch)       :     606 cycles ,     4853 ns :
lifo.put.immediate.kernel                - Add data to LIFO (no ctx switch)                   :  235034 cycles ,  1880272 ns :
lifo.get.immediate.kernel                - Get data from LIFO (no ctx switch)                 :     112 cycles ,      901 ns :
lifo.put.alloc.immediate.kernel          - Allocate to add data to LIFO (no ctx switch)       :    1150 cycles ,     9202 ns :
lifo.get.free.immediate.kernel           - Free when getting data from LIFO (no ctx switch)   :    1122 cycles ,     8979 ns :
lifo.get.blocking.k_to_k                 - Get data from LIFO (w/ ctx switch)                 :     521 cycles ,     4171 ns :
lifo.put.wake+ctx.k_to_k                 - Add data to LIFO (w/ ctx switch)                   :     606 cycles ,     4854 ns :
lifo.get.free.blocking.k_to_k            - Free when getting data from LIFO (w/ ctx switch)   :     523 cycles ,     4189 ns :
lifo.put.alloc.wake+ctx.k_to_k           - Allocate to add data to LIFO (w/ ctx switch)       :     605 cycles ,     4844 ns :
events.post.immediate.kernel             - Post events (nothing wakes)                        :     196 cycles ,     1569 ns :
events.set.immediate.kernel              - Set events (nothing wakes)                         :     197 cycles ,     1577 ns :
events.wait.immediate.kernel             - Wait for any events (no ctx switch)                :     142 cycles ,     1143 ns :
events.wait_all.immediate.kernel         - Wait for all events (no ctx switch)                :     147 cycles ,     1176 ns :
events.wait.blocking.k_to_k              - Wait for any events (w/ ctx switch)                :  235362 cycles ,  1882903 ns :
events.set.wake+ctx.k_to_k               - Set events (w/ ctx switch)                         :     668 cycles ,     5349 ns :
events.wait_all.blocking.k_to_k          - Wait for all events (w/ ctx switch)                :     598 cycles ,     4786 ns :
events.post.wake+ctx.k_to_k              - Post events (w/ ctx switch)                        :     776 cycles ,     6214 ns :
semaphore.give.immediate.kernel          - Give a semaphore (no waiters)                      :      73 cycles ,      585 ns :
semaphore.take.immediate.kernel          - Take a semaphore (no blocking)                     :      84 cycles ,      676 ns :
semaphore.take.blocking.k_to_k           - Take a semaphore (context switch)                  :     400 cycles ,     3205 ns :
semaphore.give.wake+ctx.k_to_k           - Give a semaphore (context switch)                  :     433 cycles ,     3467 ns :
condvar.wait.blocking.k_to_k             - Wait for a condvar (context switch)                :     601 cycles ,     4809 ns :
condvar.signal.wake+ctx.k_to_k           - Signal a condvar (context switch)                  :  235520 cycles ,  1884165 ns :
stack.push.immediate.kernel              - Add data to k_stack (no ctx switch)                :      90 cycles ,      724 ns :
stack.pop.immediate.kernel               - Get data from k_stack (no ctx switch)              :      82 cycles ,      662 ns :
stack.pop.blocking.k_to_k                - Get data from k_stack (w/ ctx switch)              :     512 cycles ,     4101 ns :
stack.push.wake+ctx.k_to_k               - Add data to k_stack (w/ ctx switch)                :     575 cycles ,     4606 ns :
mutex.lock.immediate.recursive.kernel    - Lock a mutex                                       :      92 cycles ,      740 ns :
mutex.unlock.immediate.recursive.kernel  - Unlock a mutex                                     :      51 cycles ,      408 ns :
heap.malloc.immediate                    - Average time for heap malloc                       :    1103 cycles ,     8830 ns :
heap.free.immediate                      - Average time for heap free                         :    1056 cycles ,     8450 ns :
===================================================================
PROJECT EXECUTION SUCCESSFUL

*** Booting Zephyr OS build v4.3.0-rc3 ***

thread.yield.preemptive.ctx.k_to_k - Context switch via k_yield : 270 cycles , 2165 ns :

thread.yield.cooperative.ctx.k_to_k - Context switch via k_yield : 267 cycles , 2142 ns :

isr.resume.interrupted.thread.kernel - Return from ISR to interrupted thread : 696 cycles , 5573 ns :

isr.resume.different.thread.kernel - Return from ISR to another thread : 1656 cycles , 13248 ns :

thread.create.kernel.from.kernel - Create thread : 358 cycles , 2870 ns :

thread.start.kernel.from.kernel - Start thread : 683 cycles , 5465 ns :

thread.suspend.kernel.from.kernel - Suspend thread : 339 cycles , 2715 ns :

thread.resume.kernel.from.kernel - Resume thread : 334 cycles , 2679 ns :

thread.abort.kernel.from.kernel - Abort thread : 236 cycles , 1895 ns :

fifo.put.immediate.kernel - Add data to FIFO (no ctx switch) : 156 cycles , 1248 ns :

fifo.get.immediate.kernel - Get data from FIFO (no ctx switch) : 114 cycles , 915 ns :

fifo.put.alloc.immediate.kernel - Allocate to add data to FIFO (no ctx switch) : 1163 cycles , 9310 ns :

fifo.get.free.immediate.kernel - Free when getting data from FIFO (no ctx switch) : 1130 cycles , 9045 ns :

fifo.get.blocking.k_to_k - Get data from FIFO (w/ ctx switch) : 235406 cycles , 1883250 ns :

fifo.put.wake+ctx.k_to_k - Add data to FIFO (w/ ctx switch) : 611 cycles , 4889 ns :

fifo.get.free.blocking.k_to_k - Free when getting data from FIFO (w/ ctx switch) : 523 cycles , 4189 ns :

fifo.put.alloc.wake+ctx.k_to_k - Allocate to add data to FIFO (w/ ctx switch) : 606 cycles , 4853 ns :

lifo.put.immediate.kernel - Add data to LIFO (no ctx switch) : 235034 cycles , 1880272 ns :

lifo.get.immediate.kernel - Get data from LIFO (no ctx switch) : 112 cycles , 901 ns :

lifo.put.alloc.immediate.kernel - Allocate to add data to LIFO (no ctx switch) : 1150 cycles , 9202 ns :

lifo.get.free.immediate.kernel - Free when getting data from LIFO (no ctx switch) : 1122 cycles , 8979 ns :

lifo.get.blocking.k_to_k - Get data from LIFO (w/ ctx switch) : 521 cycles , 4171 ns :

lifo.put.wake+ctx.k_to_k - Add data to LIFO (w/ ctx switch) : 606 cycles , 4854 ns :

lifo.get.free.blocking.k_to_k - Free when getting data from LIFO (w/ ctx switch) : 523 cycles , 4189 ns :

lifo.put.alloc.wake+ctx.k_to_k - Allocate to add data to LIFO (w/ ctx switch) : 605 cycles , 4844 ns :

events.post.immediate.kernel - Post events (nothing wakes) : 196 cycles , 1569 ns :

events.set.immediate.kernel - Set events (nothing wakes) : 197 cycles , 1577 ns :

events.wait.immediate.kernel - Wait for any events (no ctx switch) : 142 cycles , 1143 ns :

events.wait_all.immediate.kernel - Wait for all events (no ctx switch) : 147 cycles , 1176 ns :

events.wait.blocking.k_to_k - Wait for any events (w/ ctx switch) : 235362 cycles , 1882903 ns :

events.set.wake+ctx.k_to_k - Set events (w/ ctx switch) : 668 cycles , 5349 ns :

events.wait_all.blocking.k_to_k - Wait for all events (w/ ctx switch) : 598 cycles , 4786 ns :

events.post.wake+ctx.k_to_k - Post events (w/ ctx switch) : 776 cycles , 6214 ns :

semaphore.give.immediate.kernel - Give a semaphore (no waiters) : 73 cycles , 585 ns :

semaphore.take.immediate.kernel - Take a semaphore (no blocking) : 84 cycles , 676 ns :

semaphore.take.blocking.k_to_k - Take a semaphore (context switch) : 400 cycles , 3205 ns :

semaphore.give.wake+ctx.k_to_k - Give a semaphore (context switch) : 433 cycles , 3467 ns :

condvar.wait.blocking.k_to_k - Wait for a condvar (context switch) : 601 cycles , 4809 ns :

condvar.signal.wake+ctx.k_to_k - Signal a condvar (context switch) : 235520 cycles , 1884165 ns :

stack.push.immediate.kernel - Add data to k_stack (no ctx switch) : 90 cycles , 724 ns :

stack.pop.immediate.kernel - Get data from k_stack (no ctx switch) : 82 cycles , 662 ns :

stack.pop.blocking.k_to_k - Get data from k_stack (w/ ctx switch) : 512 cycles , 4101 ns :

stack.push.wake+ctx.k_to_k - Add data to k_stack (w/ ctx switch) : 575 cycles , 4606 ns :

mutex.lock.immediate.recursive.kernel - Lock a mutex : 92 cycles , 740 ns :

mutex.unlock.immediate.recursive.kernel - Unlock a mutex : 51 cycles , 408 ns :

heap.malloc.immediate - Average time for heap malloc : 1103 cycles , 8830 ns :

heap.free.immediate - Average time for heap free : 1056 cycles , 8450 ns :

===================================================================

PROJECT EXECUTION SUCCESSFUL

まとめ

Zephyr RTOSでは、デバイスの性能（処理速度や応答速度）を簡単に測定できます。

今回は同じM系コア(M33, M0+)で複数メーカで比較したテスト内容・結果を紹介しました。