DSP: add dsp unit test

add dsp context switch test
add complex multiplication test for ARC processor

Signed-off-by: Siyuan Cheng <[email protected]>

Author: Siyuan Cheng

tests/kernel/dsp_sharing/CMakeLists.txt

@@ -0,0 +1,18 @@
+# Copyright (c) 2022 Synopsys
+# SPDX-License-Identifier: Apache-2.0
+
+cmake_minimum_required(VERSION 3.20.0)
+find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
+project(dsp_sharing)
+
+target_sources(app PRIVATE
+    src/main.c
+    src/load_store.c
+    )
+
+if(CONFIG_ISA_ARCV2)
+zephyr_include_directories(
+      ${ARCMWDT_TOOLCHAIN_PATH}/MetaWare/arc/lib/src/fx/include/
+    )
+target_sources(app PRIVATE src/calculation_arc.c)
+endif()

tests/kernel/dsp_sharing/README.txt

@@ -0,0 +1,43 @@
+Title: Shared DSP Support
+
+Description:
+
+The Shared DSP Support test uses two tasks to:
+
+  1) Test load and store dsp registers (including arch specific registers)
+  2) For ARC processor: compute complex vector product and check for any errors
+
+This tests the ability of tasks to safely share dsp hardware
+resources, even when switching occurs preemptively (note that both sets of
+tests run concurrently even though they report their progress at different
+times).
+
+The demonstration utilizes semaphores, round robin scheduling, DSP and XY
+memory support.
+
+--------------------------------------------------------------------------------
+
+Sample Output:
+
+Running TESTSUITE dsp_sharing
+===================================================================
+START - test_load_store
+Load and store OK after 0 (high) + 84 (low) tests
+Load and store OK after 100 (high) + 11926 (low) tests
+Load and store OK after 200 (high) + 23767 (low) tests
+Load and store OK after 300 (high) + 35607 (low) tests
+Load and store OK after 400 (high) + 47448 (low) tests
+Load and store OK after 500 (high) + 59287 (low) tests
+ PASS - test_load_store in 10.18 seconds
+===================================================================
+START - test_calculation
+complex product calculation OK after 50 (high) + 63297 (low) tests (computed -160)
+complex product calculation OK after 150 (high) + 188138 (low) tests (computed -160)
+complex product calculation OK after 250 (high) + 312972 (low) tests (computed -160)
+complex product calculation OK after 350 (high) + 437806 (low) tests (computed -160)
+complex product calculation OK after 450 (high) + 562639 (low) tests (computed -160)
+ PASS - test_calculation in 10.16 seconds
+===================================================================
+TESTSUITE dsp_sharing succeeded
+===================================================================
+PROJECT EXECUTION SUCCESSFUL

tests/kernel/dsp_sharing/prj.conf

@@ -0,0 +1,5 @@
+CONFIG_ZTEST=y
+CONFIG_DSP=y
+CONFIG_DSP_SHARING=y
+CONFIG_MAIN_STACK_SIZE=1024
+CONFIG_ARC_DSP_BFLY_SHARING=y

tests/kernel/dsp_sharing/src/calculation_arc.c

@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) 2022 Synopsys
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*
+ * @file
+ * @brief complex number multiplication portion of DSP sharing test
+ *
+ * @ingroup kernel_dspsharing_tests
+ *
+ * This module is used for the DSP sharing test, and supplements the basic
+ * load/store test by incorporating two additional threads that utilize the
+ * DSP unit.
+ *
+ * Testing utilizes a pair of tasks that independently compute complex vector
+ * dot product. The lower priority task is regularly preempted by the higher
+ * priority task, thereby testing whether DSP context information is properly
+ * preserved.
+ *
+ * A reference value of computed result is computed once at the start of the
+ * test. All subsequent computations must produce the same value, otherwise
+ * an error has occurred.
+ */
+
+#include <ztest.h>
+#include "fxarc.h"
+#include "dsp_context.h"
+#include "test_common.h"
+
+/* stored in XY memory, need AGU_SHARING */
+#define DATA_ATTR __xy __attribute__((section(".Xdata")))
+static DATA_ATTR const cq15_t cq15_a[3] = {{0x20, 10}, {0x10, 20}, {4, 30}};
+static DATA_ATTR const cq15_t cq15_b[3] = {{0x20, 11}, {0x10, 21}, {5, 31}};
+
+static volatile short reference_result;
+
+static volatile unsigned int calc_low_count;
+static volatile unsigned int calc_high_count;
+
+/* Indicates that the load/store test exited */
+static volatile bool test_exited;
+
+/* Semaphore for signaling end of test */
+static K_SEM_DEFINE(test_exit_sem, 0, 1);
+
+/**
+ * @brief Entry point for the low priority compute task
+ *
+ * @ingroup kernel_dspsharing_tests
+ */
+static void calculate_low(void)
+{
+	volatile short res[2];
+	/* Loop until the test finishes, or an error is detected. */
+	for (calc_low_count = 0; !test_exited; calc_low_count++) {
+
+		v2accum32_t acc = {0, 0};
+
+		for (int i = 0; i < 3; i++) {
+			acc = fx_v2a32_cmac_cq15(acc, cq15_a[i], cq15_b[i]);
+		}
+		/* cast reult from v2accum32_ to short type */
+		res[0] = fx_q15_cast_asl_rnd_a32(fx_get_v2a32(acc, 0), 15);
+		res[1] = fx_q15_cast_asl_rnd_a32(fx_get_v2a32(acc, 1), 15);
+
+		if (reference_result == 0) {
+			reference_result = res[0];
+		} else if (reference_result != res[0]) {
+			printf("Computed result %d, reference result %d\n",
+			       res[0], reference_result);
+		}
+
+		zassert_equal(reference_result, res[0],
+			      "complex product computation error");
+	}
+}
+
+/**
+ * @brief Entry point for the high priority compute task
+ *
+ * @ingroup kernel_dspsharing_tests
+ */
+static void calculate_high(void)
+{
+	volatile short res[2];
+	/* Run the test until the specified maximum test count is reached */
+	for (calc_high_count = 0; calc_high_count <= MAX_TESTS;
+	     calc_high_count++) {
+
+		v2accum32_t acc = {0, 0};
+
+		for (int i = 0; i < 3; i++) {
+			acc = fx_v2a32_cmac_cq15(acc, cq15_a[i], cq15_b[i]);
+		}
+
+		/*
+		 * Relinquish the processor for the remainder of the current
+		 * system clock tick, so that lower priority threads get a
+		 * chance to run.
+		 *
+		 * This exercises the ability of the kernel to restore the
+		 * DSP state of a low priority thread _and_ the ability of the
+		 * kernel to provide a "clean" DSP state to this thread
+		 * once the sleep ends.
+		 */
+		k_sleep(K_MSEC(10));
+
+		res[0] = fx_q15_cast_asl_rnd_a32(fx_get_v2a32(acc, 0), 15);
+		res[1] = fx_q15_cast_asl_rnd_a32(fx_get_v2a32(acc, 1), 15);
+
+		if (reference_result == 0) {
+			reference_result = res[0];
+		} else if (reference_result != res[0]) {
+			printf("Computed result %d, reference result %d\n",
+			       res[0], reference_result);
+		}
+
+		zassert_equal(reference_result, res[0],
+			      "complex product computation error");
+
+		/* Periodically issue progress report */
+		if ((calc_high_count % 100) == 50) {
+			printf("complex product calculation OK after %u (high) "
+			       "+"
+			       " %u (low) tests (computed %d)\n",
+			       calc_high_count, calc_low_count, res[0]);
+		}
+	}
+
+	/* Signal end of test */
+	test_exited = true;
+	k_sem_give(&test_exit_sem);
+}
+
+K_THREAD_DEFINE(cal_low, THREAD_STACK_SIZE, calculate_low, NULL, NULL, NULL,
+		THREAD_LOW_PRIORITY, K_DSP_REGS | K_AGU_REGS, K_TICKS_FOREVER);
+
+K_THREAD_DEFINE(cal_high, THREAD_STACK_SIZE, calculate_high, NULL, NULL, NULL,
+		THREAD_HIGH_PRIORITY, K_DSP_REGS | K_AGU_REGS, K_TICKS_FOREVER);
+
+void test_calculation(void)
+{
+	/* Initialise test states */
+	test_exited = false;
+	k_sem_reset(&test_exit_sem);
+
+	/* Start test threads */
+	k_thread_start(cal_low);
+	k_thread_start(cal_high);
+
+	/* Wait for test threads to exit */
+	k_sem_take(&test_exit_sem, K_FOREVER);
+}

tests/kernel/dsp_sharing/src/dsp_context.h

@@ -0,0 +1,76 @@
+/**
+ * @file
+ * @brief common definitions for the DSP sharing test application
+ */
+
+/*
+ * Copyright (c) 2022 Synopsys
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef _DSPCONTEXT_H
+#define _DSPCONTEXT_H
+
+/*
+ * Each architecture must define the following structures (which may be empty):
+ *      'struct dsp_volatile_register_set'
+ *      'struct dsp_non_volatile_register_set'
+ *
+ * Each architecture must also define the following macros:
+ *      SIZEOF_DSP_VOLATILE_REGISTER_SET
+ *      SIZEOF_DSP_NON_VOLATILE_REGISTER_SET
+ * Those macros are used as sizeof(<an empty structure>) is compiler specific;
+ * that is, it may evaluate to a non-zero value.
+ *
+ * Each architecture shall also have custom implementations of:
+ *     _load_all_dsp_registers()
+ *     _load_then_store_all_dsp_registers()
+ *     _store_all_dsp_registers()
+ */
+
+#if defined(CONFIG_ISA_ARCV2)
+
+struct dsp_volatile_register_set {
+#ifdef CONFIG_ARC_DSP_BFLY_SHARING
+	uintptr_t dsp_bfly0;
+	uintptr_t agu_ap0;
+	uintptr_t agu_os0;
+#endif
+};
+
+struct dsp_non_volatile_register_set {
+	/* No non-volatile dsp registers */
+};
+
+#define SIZEOF_DSP_VOLATILE_REGISTER_SET sizeof(struct dsp_volatile_register_set)
+#define SIZEOF_DSP_NON_VOLATILE_REGISTER_SET 0
+
+#else
+
+#error  "Architecture must provide the following definitions:\n"
+"\t'struct dsp_volatile_registers'\n"
+"\t'struct dsp_non_volatile_registers'\n"
+"\t'SIZEOF_DSP_VOLATILE_REGISTER_SET'\n"
+"\t'SIZEOF_DSP_NON_VOLATILE_REGISTER_SET'\n"
+#endif /* CONFIG_ISA_ARCV2 */
+
+/* the set of ALL dsp registers */
+
+struct dsp_register_set {
+	struct dsp_volatile_register_set dsp_volatile;
+	struct dsp_non_volatile_register_set dsp_non_volatile;
+};
+
+#define SIZEOF_DSP_REGISTER_SET \
+	(SIZEOF_DSP_VOLATILE_REGISTER_SET + SIZEOF_DSP_NON_VOLATILE_REGISTER_SET)
+
+/*
+ * The following constants define the initial byte value used by the background
+ * task, and the thread when loading up the dsp registers.
+ */
+
+#define MAIN_DSP_REG_CHECK_BYTE ((unsigned char)0xe5)
+#define FIBER_DSP_REG_CHECK_BYTE ((unsigned char)0xf9)
+
+#endif /* _DSPCONTEXT_H */