worker cleanups

Signed-off-by: Serhiy Katsyuba <serhiy.katsyuba@intel.com>

Author: serhiy-katsyuba-intel

src/audio/module_adapter/library/userspace_proxy.c

@@ -56,10 +56,14 @@ static const struct module_interface userspace_proxy_interface;
 
 static inline int user_worker_get(int cpu)
 {
+	ARG_UNUSED(cpu);
 	return 0;
 }
 
-static inline void user_worker_put(int cpu) { }
+static inline void user_worker_put(int cpu)
+{
+	ARG_UNUSED(cpu);
+}
 
 struct k_work_user *userspace_proxy_register_ipc_handler(struct processing_module *mod,
 							 struct k_event *event)
@@ -86,9 +90,10 @@ struct k_work_user *userspace_proxy_register_ipc_handler(struct processing_modul
  * It invokes the appropriate module function in userspace context and writes the operation
  * result back into the work item.
  *
- * There is only a single work queue, which is shared by all userspace modules. It is created
- * dynamically when needed. Because SOF uses a single dedicated thread for handling IPC, there
- * is no need to perform any additional serialization when accessing the worker.
+ * There is a separate work queue per core. Each core's work queue is shared by all
+ * userspace modules running on that core and is created dynamically when needed. A given
+ * core's worker is only accessed from that same core's IPC handling context, so there is no
+ * need to perform any additional serialization when accessing it.
  */
 struct user_worker {
 	k_tid_t thread_id;			/* ipc worker thread ID			*/
@@ -100,36 +105,17 @@ struct user_worker {
 
 static struct user_worker worker[CONFIG_CORE_COUNT];
 
-#if 0
-static void sof_work_user_queue_init(struct k_work_user_q *work_q, k_thread_stack_t *stack,
-			     size_t stack_size, int prio, const char *name)
-{
-	k_queue_init(&work_q->queue);
-
-	/* Created worker thread will inherit object permissions and memory
-	 * domain configuration of the caller
-	 */
-	k_thread_create(&work_q->thread, stack, stack_size, z_work_user_q_main,
-			work_q, NULL, NULL, prio, K_USER | K_INHERIT_PERMS,
-			K_FOREVER);
-	k_object_access_grant(&work_q->queue, &work_q->thread);
-	if (name != NULL) {
-		k_thread_name_set(&work_q->thread, name);
-	}
-
-	///k_thread_start(&work_q->thread);
-}
-#endif	// 0
-
 static int user_worker_get(int cpu)
 {
+	assert(cpu >= 0 && cpu < (int)ARRAY_SIZE(worker));
+
 	if (worker[cpu].reference_count) {
 		worker[cpu].reference_count++;
 		return 0;
 	}
 
 	worker[cpu].stack_ptr = user_stack_allocate(CONFIG_SOF_USERSPACE_PROXY_WORKER_STACK_SIZE,
-					       K_USER);
+						K_USER);
 	if (!worker[cpu].stack_ptr) {
 		tr_err(&userspace_proxy_tr, "Userspace worker stack allocation failed.");
 		return -ENOMEM;
@@ -141,6 +127,10 @@ static int user_worker_get(int cpu)
 
 	worker[cpu].thread_id = k_work_user_queue_thread_get(&worker[cpu].work_queue);
 
+	/*
+	 * k_work_user_queue_start() starts the worker thread immediately.
+	 * We need to make sure it is not running when pinning it to a specific core.
+	 */
 	k_thread_suspend(worker[cpu].thread_id);
 
 	/* Pin worker thread to the same core as the module */
@@ -157,6 +147,8 @@ static int user_worker_get(int cpu)
 
 static void user_worker_put(int cpu)
 {
+	assert(cpu >= 0 && cpu < (int)ARRAY_SIZE(worker));
+
 	/* Module removed so decrement counter */
 	worker[cpu].reference_count--;
 
@@ -178,10 +170,7 @@ static int user_work_item_init(struct userspace_context *user_ctx, struct k_heap
 	if (ret)
 		return ret;
 
-	/* We have only a single userspace IPC worker. It handles requests for all userspace
-	 * modules, which may run on different cores. Because the worker processes work items
-	 * coming from any core, the work item must be allocated in coherent memory.
-	 */
+	/* TODO: this can probably be allocated as cached? */
 	work_item = sof_heap_alloc(user_heap, SOF_MEM_FLAG_COHERENT, sizeof(*work_item), 0);
 	if (!work_item) {
 		user_worker_put(cpu);
@@ -253,17 +242,6 @@ static int userspace_proxy_invoke(struct userspace_context *user_ctx, uint32_t c
 		goto done;
 	}
 
-#if 0
-#ifdef CONFIG_SCHED_CPU_MASK
-	/* Pin worker thread to the same core as the module */
-	ret = k_thread_cpu_pin(worker[cpu].thread_id, cpu);
-	if (ret < 0) {
-		tr_err(&userspace_proxy_tr, "Failed to pin cpu, error: %d", ret);
-		goto done;
-	}
-#endif
-#endif	// 0
-
 	ret = k_work_user_submit_to_queue(&worker[cpu].work_queue, &user_ctx->work_item->work_item);
 	if (ret < 0) {
 		tr_err(&userspace_proxy_tr, "Submit to queue error: %d", ret);