dp: fork and optimise a native version

Fork a version of the deviating DP functions for a native (proxy-
free) implementation. The first deviation is the removal of task
recalculation at the end of DP task runs. DP tasks are recalculated
on every LL tick (typically every 1ms). DP threads then run with
varying periodicity and duration. They can take 10 or even 100ms to
run. Also recalculating tasks in the end of those runs doesn't
improve anything and only adds load and a need to protect data. This
is even worse when DP threads run in user space. Skip recalculation
for the native version.

Signed-off-by: Guennadi Liakhovetski <guennadi.liakhovetski@linux.intel.com>

Author: lyakh

src/schedule/CMakeLists.txt

@@ -38,10 +38,17 @@ else()
 	)
 endif()
 
-zephyr_library_sources_ifdef(CONFIG_ZEPHYR_DP_SCHEDULER
-	zephyr_dp_schedule.c
-	zephyr_dp_schedule_proxy.c
-)
+if (CONFIG_SOF_USERSPACE_PROXY OR NOT CONFIG_USERSPACE)
+	zephyr_library_sources_ifdef(CONFIG_ZEPHYR_DP_SCHEDULER
+		zephyr_dp_schedule.c
+		zephyr_dp_schedule_proxy.c
+	)
+else()
+	zephyr_library_sources_ifdef(CONFIG_ZEPHYR_DP_SCHEDULER
+		zephyr_dp_schedule.c
+		zephyr_dp_schedule_native.c
+	)
+endif()
 
 zephyr_library_sources_ifdef(CONFIG_ZEPHYR_TWB_SCHEDULER
 	zephyr_twb_schedule.c

src/schedule/zephyr_dp_schedule_native.c

@@ -0,0 +1,159 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/*
+ * Copyright(c) 2025 Intel Corporation. All rights reserved.
+ *
+ * Author: Marcin Szkudlinski
+ */
+
+#include <rtos/task.h>
+
+#include <sof/audio/module_adapter/module/generic.h>
+#include <sof/common.h>
+#include <sof/list.h>
+#include <sof/schedule/ll_schedule_domain.h>
+
+#include <zephyr/kernel.h>
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "zephyr_dp_schedule.h"
+
+/* Go through all DP tasks and recalculate their readiness and deadlines
+ * NOT REENTRANT, should be called with scheduler_dp_lock()
+ */
+void scheduler_dp_recalculate(struct scheduler_dp_data *dp_sch, bool is_ll_post_run)
+{
+	struct list_item *tlist;
+	struct task *curr_task;
+	struct task_dp_pdata *pdata;
+
+	list_for_item(tlist, &dp_sch->tasks) {
+		curr_task = container_of(tlist, struct task, list);
+		pdata = curr_task->priv_data;
+		struct processing_module *mod = pdata->mod;
+		bool trigger_task = false;
+
+		/* decrease number of LL ticks/cycles left till the module reaches its deadline */
+		if (mod->dp_startup_delay && is_ll_post_run && pdata->ll_cycles_to_start) {
+			pdata->ll_cycles_to_start--;
+			if (!pdata->ll_cycles_to_start)
+				/* delayed start complete, clear startup delay flag.
+				 * see dp_startup_delay comment for details
+				 */
+				mod->dp_startup_delay = false;
+		}
+
+		if (curr_task->state == SOF_TASK_STATE_QUEUED) {
+			bool mod_ready;
+
+			mod_ready = module_is_ready_to_process(mod, mod->sources,
+							       mod->num_of_sources,
+							       mod->sinks,
+							       mod->num_of_sinks);
+			if (mod_ready) {
+				/* trigger the task */
+				curr_task->state = SOF_TASK_STATE_RUNNING;
+				if (mod->dp_startup_delay && !pdata->ll_cycles_to_start) {
+					/* first time run - use delayed start */
+					pdata->ll_cycles_to_start =
+						module_get_lpt(pdata->mod) / LL_TIMER_PERIOD_US;
+
+					/* in case LPT < LL cycle - delay at least cycle */
+					if (!pdata->ll_cycles_to_start)
+						pdata->ll_cycles_to_start = 1;
+				}
+				trigger_task = true;
+				k_sem_give(pdata->sem);
+			}
+		}
+		if (curr_task->state == SOF_TASK_STATE_RUNNING) {
+			/* (re) calculate deadline for all running tasks */
+			/* get module deadline in us*/
+			uint32_t deadline = module_get_deadline(mod);
+
+			/* if a deadline cannot be calculated, use a fixed value relative to its
+			 * first start
+			 */
+			if (deadline >= UINT32_MAX / 2 && trigger_task)
+				deadline = module_get_lpt(mod);
+
+			if (deadline < UINT32_MAX) {
+				/* round down to 1ms */
+				deadline = deadline / 1000;
+
+				/* calculate number of ticks */
+				deadline = deadline * (CONFIG_SYS_CLOCK_HW_CYCLES_PER_SEC / 1000);
+
+				/* add to "NOW", overflows are OK  */
+				deadline = dp_sch->last_ll_tick_timestamp + deadline;
+
+				/* set in Zephyr. Note that it may be in past, it does not matter,
+				 * Zephyr still will schedule the thread with earlier deadline
+				 * first
+				 */
+				k_thread_absolute_deadline_set(pdata->thread_id, deadline);
+			}
+		}
+	}
+}
+
+/* Thread function called in component context, on target core */
+void dp_thread_fn(void *p1, void *p2, void *p3)
+{
+	struct task *task = p1;
+	(void)p2;
+	(void)p3;
+	struct task_dp_pdata *task_pdata = task->priv_data;
+	unsigned int lock_key;
+	enum task_state state;
+	bool task_stop;
+
+	do {
+		/*
+		 * the thread is started immediately after creation, it will stop on semaphore
+		 * Semaphore will be released once the task is ready to process
+		 */
+		k_sem_take(task_pdata->sem, K_FOREVER);
+
+		if (task->state == SOF_TASK_STATE_RUNNING)
+			state = task_run(task);
+		else
+			state = task->state;	/* to avoid undefined variable warning */
+
+		lock_key = scheduler_dp_lock(task->core);
+		/*
+		 * check if task is still running, may have been canceled by external call
+		 * if not, set the state returned by run procedure
+		 */
+		if (task->state == SOF_TASK_STATE_RUNNING) {
+			task->state = state;
+			switch (state) {
+			case SOF_TASK_STATE_RESCHEDULE:
+				/* mark to reschedule, schedule time is already calculated */
+				task->state = SOF_TASK_STATE_QUEUED;
+				break;
+
+			case SOF_TASK_STATE_CANCEL:
+			case SOF_TASK_STATE_COMPLETED:
+				/* remove from scheduling */
+				list_item_del(&task->list);
+				break;
+
+			default:
+				/* illegal state, serious defect, won't happen */
+				k_panic();
+			}
+		}
+
+		/* if true exit the while loop, terminate the thread */
+		task_stop = task->state == SOF_TASK_STATE_COMPLETED ||
+			task->state == SOF_TASK_STATE_CANCEL;
+
+		scheduler_dp_unlock(lock_key);
+	} while (!task_stop);
+
+	/* call task_complete  */
+	if (task->state == SOF_TASK_STATE_COMPLETED)
+		task_complete(task);
+}