samples: userspace: syscall_perf

The goal of this sample application is to measure the performance loss
when a user thread has to go through a system call compared to a
supervisor thread that calls the function directly.

Signed-off-by: Nicolas Royer <[email protected]>

Author: nroyer-baylibre

samples/userspace/syscall_perf/CMakeLists.txt

@@ -0,0 +1,20 @@
+# SPDX-License-Identifier: Apache-2.0
+
+cmake_minimum_required(VERSION 3.13.1)
+
+include($ENV{ZEPHYR_BASE}/cmake/app/boilerplate.cmake NO_POLICY_SCOPE)
+project(syscall_perf)
+
+set_property(
+   SOURCE src/test_user.c
+   PROPERTY COMPILE_DEFINITIONS
+     __ZEPHYR_USER__
+)
+
+set_property(
+   SOURCE src/test_supervisor.c
+   PROPERTY COMPILE_DEFINITIONS
+     __ZEPHYR_SUPERVISOR__
+)
+
+target_sources(app PRIVATE src/main.c src/test_user.c src/test_supervisor.c)

samples/userspace/syscall_perf/README.rst

@@ -0,0 +1,32 @@
+.. _syscall_perf:
+
+Syscall performances
+====================
+
+The goal of this sample application is to measure the performance loss when a
+user thread has to go through a system call compared to a supervisor thread that
+calls the function directly.
+
+
+Overview
+********
+
+This application creates a supervisor and a user thread.
+Then both threads call k_current_get() which returns a reference to the
+current thread. The user thread has to go through a system call.
+
+Both threads are showing the number of core clock cycles and the number of
+instructions executed while calling k_current_get().
+
+
+Sample Output
+*************
+
+.. code-block:: console
+
+    User thread:		   18012 cycles	     748 instructions
+    Supervisor thread:	       7 cycles	       4 instructions
+    User thread:		   20136 cycles	     748 instructions
+    Supervisor thread:	       7 cycles	       4 instructions
+    User thread:		   18014 cycles	     748 instructions
+    Supervisor thread:	       7 cycles	       4 instructions

samples/userspace/syscall_perf/prj.conf

@@ -0,0 +1,6 @@
+CONFIG_USERSPACE=y
+CONFIG_APPLICATION_DEFINED_SYSCALL=y
+CONFIG_ASSERT=y
+CONFIG_LOG=y
+CONFIG_LOG_MINIMAL=y
+CONFIG_MAIN_STACK_SIZE=2560

samples/userspace/syscall_perf/sample.yaml

@@ -0,0 +1,14 @@
+sample:
+  description: syscall performances sample
+  name: syscall performances
+common:
+    tags: userspace
+    harness: console
+    harness_config:
+      type: one_line
+      regex:
+        - "User thread"
+tests:
+  sample.syscall_performances:
+    filter: CONFIG_ARCH_HAS_USERSPACE
+    platform_allow: riscv32

samples/userspace/syscall_perf/src/main.c

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2020 BayLibre, SAS
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <zephyr.h>
+#include <stdio.h>
+
+#include "main.h"
+#include "thread_def.h"
+
+void main(void)
+{
+	printf("Main Thread started; %s\n", CONFIG_BOARD);
+
+	k_thread_create(&supervisor_thread, supervisor_stack, THREAD_STACKSIZE,
+			supervisor_thread_function, NULL, NULL, NULL,
+			-1, K_INHERIT_PERMS, K_NO_WAIT);
+
+	k_sleep(K_MSEC(1000));
+
+	k_thread_create(&user_thread, user_stack, THREAD_STACKSIZE,
+			user_thread_function, NULL, NULL, NULL,
+			-1, K_USER | K_INHERIT_PERMS, K_NO_WAIT);
+}

samples/userspace/syscall_perf/src/main.h

@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2020 BayLibre, SAS
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef MAIN_H
+#define MAIN_H
+
+#include <kernel.h>
+
+#define csr_read(csr)						\
+({								\
+	register unsigned long __v;				\
+	__asm__ volatile ("csrr %0, " #csr			\
+				: "=r" (__v));			\
+	__v;							\
+})
+
+#endif  /* MAIN_H */

samples/userspace/syscall_perf/src/test_supervisor.c

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2020 BayLibre, SAS
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <zephyr.h>
+#include <stdio.h>
+
+#include "main.h"
+
+/*
+ * 0xB00 is CSR mcycle
+ * 0xB02 is CSR minstret
+ */
+void supervisor_thread_function(void *p1, void *p2, void *p3)
+{
+	register unsigned long cycle_before, cycle_count;
+	register unsigned long inst_before, inst_count;
+
+	printf("Supervisor thread started\n");
+
+	while (1) {
+		k_sleep(K_MSEC(2000));
+
+		inst_before = csr_read(0xB02);
+		cycle_before = csr_read(0xB00);
+		k_current_get();
+		cycle_count = csr_read(0xB00);
+		inst_count = csr_read(0xB02);
+
+		if (cycle_count > cycle_before) {
+			cycle_count -= cycle_before;
+		} else {
+			cycle_count += 0xFFFFFFFF - cycle_before;
+		}
+
+		if (inst_count > inst_before) {
+			inst_count -= inst_before;
+		} else {
+			inst_count += 0xFFFFFFFF - inst_before;
+		}
+
+		/* Remove CSR accesses to be more accurate */
+		inst_count -= 3;
+
+		printf("Supervisor thread:\t%8lu cycles\t%8lu instructions\n",
+			cycle_count, inst_count);
+	}
+}

samples/userspace/syscall_perf/src/test_user.c

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2020 BayLibre, SAS
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <zephyr.h>
+#include <stdio.h>
+
+#include "main.h"
+
+/*
+ * 0xC00 is CSR cycle
+ * 0xC02 is CSR instret
+ */
+void user_thread_function(void *p1, void *p2, void *p3)
+{
+	register unsigned long cycle_before, cycle_count;
+	register unsigned long inst_before, inst_count;
+
+	printf("User thread started\n");
+
+	while (1) {
+		k_sleep(K_MSEC(2000));
+
+		inst_before = csr_read(0xC02);
+		cycle_before = csr_read(0xC00);
+		k_current_get();
+		cycle_count = csr_read(0xC00);
+		inst_count = csr_read(0xC02);
+
+		if (cycle_count > cycle_before) {
+			cycle_count -= cycle_before;
+		} else {
+			cycle_count += 0xFFFFFFFF - cycle_before;
+		}
+
+		if (inst_count > inst_before) {
+			inst_count -= inst_before;
+		} else {
+			inst_count += 0xFFFFFFFF - inst_before;
+		}
+
+		/* Remove CSR accesses to be more accurate */
+		inst_count -= 3;
+
+		printf("User thread:\t\t%8lu cycles\t%8lu instructions\n",
+			cycle_count, inst_count);
+	}
+}

samples/userspace/syscall_perf/src/thread_def.h

@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2020 BayLibre, SAS
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef THREAD_DEF_H
+#define THREAD_DEF_H
+
+#include <kernel.h>
+
+#define THREAD_STACKSIZE	2048
+
+struct k_thread user_thread;
+K_THREAD_STACK_DEFINE(user_stack, THREAD_STACKSIZE);
+void supervisor_thread_function(void *p1, void *p2, void *p3);
+
+struct k_thread supervisor_thread;
+K_THREAD_STACK_DEFINE(supervisor_stack, THREAD_STACKSIZE);
+void user_thread_function(void *p1, void *p2, void *p3);
+
+#endif /* THREAD_DEF_H */