zephyr/tests/benchmarks/sched/README.rst

Scheduler Microbenchmark
########################

This is a scheduler microbenchmark, designed to measure minimum
latencies (not scaling performance) of specific low level scheduling
primitives independent of overhead from application or API
abstractions.  It works very simply: a main thread creates a "partner"
thread at a higher priority, the partner then sleeps using
_pend_curr_irqlock().  From this initial state:

1. The main thread calls _unpend_first_thread()
2. The main thread calls _ready_thread()
3. The main thread calls k_yield()
   (the kernel switches to the partner thread)
4. The partner thread then runs and calls _pend_curr_irqlock() again
   (the kernel switches to the main thread)
5. The main thread returns from k_yield()

It then iterates this many times, reporting timestamp latencies
between each numbered step and for the whole cycle, and a running
average for all cycles run.
tests/benchmarks: Add scheduler microbenchmark Useful tool for performance work that removes interaction with other APIs and thread state. The best part is that it doesn't rely on timer interrupt delivery and so works with -icount even on existing qemu versions and produces deterministic output. Signed-off-by: Andy Ross <andrew.j.ross@intel.com> 2019-01-29 01:32:48 +08:00			`Scheduler Microbenchmark`
			`########################`

			`This is a scheduler microbenchmark, designed to measure minimum`
			`latencies (not scaling performance) of specific low level scheduling`
			`primitives independent of overhead from application or API`
			`abstractions. It works very simply: a main thread creates a "partner"`
			`thread at a higher priority, the partner then sleeps using`
kernel: Split reschdule & pend into irq/spin lock versions Just like with _Swap(), we need two variants of these utilities which can atomically release a lock and context switch. The naming shifts (for byte count reasons) to _reschedule/_pend_curr, and both have an _irqlock variant which takes the traditional locking. Just refactoring. No logic changes. Signed-off-by: Andy Ross <andrew.j.ross@intel.com> 2018-07-25 04:37:59 +08:00			`_pend_curr_irqlock(). From this initial state:`
tests/benchmarks: Add scheduler microbenchmark Useful tool for performance work that removes interaction with other APIs and thread state. The best part is that it doesn't rely on timer interrupt delivery and so works with -icount even on existing qemu versions and produces deterministic output. Signed-off-by: Andy Ross <andrew.j.ross@intel.com> 2019-01-29 01:32:48 +08:00
			`1. The main thread calls _unpend_first_thread()`
			`2. The main thread calls _ready_thread()`
			`3. The main thread calls k_yield()`
			`(the kernel switches to the partner thread)`
kernel: Split reschdule & pend into irq/spin lock versions Just like with _Swap(), we need two variants of these utilities which can atomically release a lock and context switch. The naming shifts (for byte count reasons) to _reschedule/_pend_curr, and both have an _irqlock variant which takes the traditional locking. Just refactoring. No logic changes. Signed-off-by: Andy Ross <andrew.j.ross@intel.com> 2018-07-25 04:37:59 +08:00			`4. The partner thread then runs and calls _pend_curr_irqlock() again`
tests/benchmarks: Add scheduler microbenchmark Useful tool for performance work that removes interaction with other APIs and thread state. The best part is that it doesn't rely on timer interrupt delivery and so works with -icount even on existing qemu versions and produces deterministic output. Signed-off-by: Andy Ross <andrew.j.ross@intel.com> 2019-01-29 01:32:48 +08:00			`(the kernel switches to the main thread)`
			`5. The main thread returns from k_yield()`

			`It then iterates this many times, reporting timestamp latencies`
			`between each numbered step and for the whole cycle, and a running`
			`average for all cycles run.`