use queues per core

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

Author: serhiy-katsyuba-intel

src/audio/module_adapter/library/userspace_proxy.c

@@ -98,53 +98,79 @@ struct user_worker {
 	struct k_event event;
 };
 
-static struct user_worker worker;
+static struct user_worker worker[CONFIG_CORE_COUNT];
 
-static int user_worker_get(void)
+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)
 {
-	if (worker.reference_count) {
-		worker.reference_count++;
+	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);
+}
+
+static int user_worker_get(int cpu)
+{
+	if (worker[cpu].reference_count) {
+		worker[cpu].reference_count++;
 		return 0;
 	}
 
-	worker.stack_ptr = user_stack_allocate(CONFIG_SOF_USERSPACE_PROXY_WORKER_STACK_SIZE,
+	worker[cpu].stack_ptr = user_stack_allocate(CONFIG_SOF_USERSPACE_PROXY_WORKER_STACK_SIZE,
 					       K_USER);
-	if (!worker.stack_ptr) {
+	if (!worker[cpu].stack_ptr) {
 		tr_err(&userspace_proxy_tr, "Userspace worker stack allocation failed.");
 		return -ENOMEM;
 	}
 
-	k_event_init(&worker.event);
-	k_work_user_queue_start(&worker.work_queue, worker.stack_ptr,
+	k_event_init(&worker[cpu].event);
+	sof_work_user_queue_init(&worker[cpu].work_queue, worker[cpu].stack_ptr,
 				CONFIG_SOF_USERSPACE_PROXY_WORKER_STACK_SIZE, 0, NULL);
 
-	worker.thread_id = k_work_user_queue_thread_get(&worker.work_queue);
+	worker[cpu].thread_id = k_work_user_queue_thread_get(&worker[cpu].work_queue);
+
+	/* Pin worker thread to the same core as the module */
+	k_thread_cpu_pin(worker[cpu].thread_id, cpu);
+
+	k_thread_access_grant(worker[cpu].thread_id, &worker[cpu].event);
+
+	worker[cpu].reference_count++;
 
-	k_thread_access_grant(worker.thread_id, &worker.event);
+	k_thread_start(&worker[cpu].work_queue.thread);
 
-	worker.reference_count++;
 	return 0;
 }
 
-static void user_worker_put(void)
+static void user_worker_put(int cpu)
 {
 	/* Module removed so decrement counter */
-	worker.reference_count--;
+	worker[cpu].reference_count--;
 
 	/* Free worker resources if no more active user space modules */
-	if (worker.reference_count == 0) {
-		k_thread_abort(worker.thread_id);
-		user_stack_free(worker.stack_ptr);
+	if (worker[cpu].reference_count == 0) {
+		k_thread_abort(worker[cpu].thread_id);
+		user_stack_free(worker[cpu].stack_ptr);
 	}
 }
 #endif
 
 static int user_work_item_init(struct userspace_context *user_ctx, struct k_heap *user_heap)
 {
+	int cpu = cpu_get_id();
 	struct user_work_item *work_item = NULL;
 	int ret;
 
-	ret = user_worker_get();
+	ret = user_worker_get(cpu);
 	if (ret)
 		return ret;
 
@@ -154,14 +180,14 @@ static int user_work_item_init(struct userspace_context *user_ctx, struct k_heap
 	 */
 	work_item = sof_heap_alloc(user_heap, SOF_MEM_FLAG_COHERENT, sizeof(*work_item), 0);
 	if (!work_item) {
-		user_worker_put();
+		user_worker_put(cpu);
 		return -ENOMEM;
 	}
 
 	k_work_user_init(&work_item->work_item, userspace_proxy_worker_handler);
 
 #if !IS_ENABLED(CONFIG_SOF_USERSPACE_MOD_IPC_BY_DP_THREAD)
-	work_item->event = &worker.event;
+	work_item->event = &worker[cpu].event;
 #endif
 	work_item->params.context = user_ctx;
 	work_item->params.mod = NULL;
@@ -173,7 +199,7 @@ static int user_work_item_init(struct userspace_context *user_ctx, struct k_heap
 static void user_work_item_free(struct userspace_context *user_ctx, struct k_heap *user_heap)
 {
 	sof_heap_free(user_heap, user_ctx->work_item);
-	user_worker_put();
+	user_worker_put(cpu_get_id());
 }
 
 static inline struct module_params *user_work_get_params(struct userspace_context *user_ctx)
@@ -193,7 +219,8 @@ static int userspace_proxy_invoke(struct userspace_context *user_ctx, uint32_t c
 #if IS_ENABLED(CONFIG_SOF_USERSPACE_MOD_IPC_BY_DP_THREAD)
 	struct k_event * const event = user_ctx->dp_event;
 #else
-	struct k_event * const event = &worker.event;
+	int cpu = cpu_get_id();
+	struct k_event * const event = &worker[cpu].event;
 #endif
 	struct module_params *params = user_work_get_params(user_ctx);
 	const uintptr_t ipc_req_buf = (uintptr_t)MAILBOX_HOSTBOX_BASE;
@@ -216,22 +243,24 @@ static int userspace_proxy_invoke(struct userspace_context *user_ctx, uint32_t c
 
 #if !IS_ENABLED(CONFIG_SOF_USERSPACE_MOD_IPC_BY_DP_THREAD)
 	/* Switch worker thread to module memory domain */
-	ret = k_mem_domain_add_thread(user_ctx->comp_dom, worker.thread_id);
+	ret = k_mem_domain_add_thread(user_ctx->comp_dom, worker[cpu].thread_id);
 	if (ret < 0) {
 		tr_err(&userspace_proxy_tr, "Failed to switch memory domain, error: %d", ret);
 		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.thread_id, cpu_get_id());
+	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.work_queue, &user_ctx->work_item->work_item);
+	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);
 		goto done;