audio: module: simplify resource allocation context

Merge struct mod_alloc_ctx and struct dp_heap_user. We still need a
separately allocated allocation context to make sure it persists when
the module adapter object is freed but some of the connected buffers
still exist, so struct mod_alloc_ctx now becomes that separate
context.

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

Author: lyakh

src/audio/buffers/comp_buffer.c

@@ -162,11 +162,9 @@ static void comp_buffer_free(struct sof_audio_buffer *audio_buffer)
 	else
 		sof_heap_free(alloc ? alloc->heap : NULL, buffer);
 
-	if (alloc && alloc->client && !--alloc->client->client_count) {
-		rfree(alloc->client);
-		alloc->client = NULL;
-		/* NULL is allowed */
+	if (alloc && !--alloc->client_count) {
 		vregion_put(alloc->vreg);
+		rfree(alloc);
 	}
 }
 

src/audio/buffers/ring_buffer.c

@@ -294,7 +294,7 @@ struct ring_buffer *ring_buffer_create(struct comp_dev *dev, size_t min_availabl
 				       uint32_t id)
 {
 	struct ring_buffer *ring_buffer;
-	struct mod_alloc_ctx *alloc = &dev->mod->priv.resources.alloc;
+	struct mod_alloc_ctx *alloc = dev->mod->priv.resources.alloc;
 	struct k_heap *heap = alloc->heap;
 	struct vregion *vreg = alloc->vreg;
 	int memory_flags = (is_shared ? SOF_MEM_FLAG_COHERENT : 0) |

src/audio/module_adapter/module/generic.c

@@ -86,7 +86,7 @@ void mod_resource_init(struct processing_module *mod)
 
 	/* Init memory list */
 	list_init(&md->resources.objpool.list);
-	md->resources.objpool.heap = md->resources.alloc.heap;
+	md->resources.objpool.heap = md->resources.alloc->heap;
 	md->resources.heap_usage = 0;
 	md->resources.heap_high_water_mark = 0;
 }
@@ -159,10 +159,10 @@ void mod_heap_info(struct processing_module *mod, size_t *size, uintptr_t *start
 	struct module_resources *res = &mod->priv.resources;
 
 	if (size)
-		*size = res->alloc.heap->heap.init_bytes;
+		*size = res->alloc->heap->heap.init_bytes;
 
 	if (start)
-		*start = (uintptr_t)res->alloc.client;
+		*start = (uintptr_t)res->alloc->heap;
 }
 #endif
 
@@ -195,7 +195,7 @@ void *mod_balloc_align(struct processing_module *mod, size_t size, size_t alignm
 	}
 
 	/* Allocate buffer memory for module */
-	void *ptr = sof_heap_alloc(res->alloc.heap, SOF_MEM_FLAG_USER | SOF_MEM_FLAG_LARGE_BUFFER,
+	void *ptr = sof_heap_alloc(res->alloc->heap, SOF_MEM_FLAG_USER | SOF_MEM_FLAG_LARGE_BUFFER,
 				   size, alignment);
 
 	if (!ptr) {
@@ -246,7 +246,7 @@ void *z_impl_mod_alloc_ext(struct processing_module *mod, uint32_t flags, size_t
 	}
 
 	/* Allocate memory for module */
-	void *ptr = sof_heap_alloc(res->alloc.heap, flags, size, alignment);
+	void *ptr = sof_heap_alloc(res->alloc->heap, flags, size, alignment);
 
 	if (!ptr) {
 		comp_err(mod->dev, "Failed to alloc %zu bytes %zu alignment for comp %#x.",
@@ -323,7 +323,7 @@ const void *z_impl_mod_fast_get(struct processing_module *mod, const void * cons
 	if (!container)
 		return NULL;
 
-	ptr = fast_get(res->alloc.heap, dram_ptr, size);
+	ptr = fast_get(res->alloc->heap, dram_ptr, size);
 	if (!ptr) {
 		container_put(mod, container);
 		return NULL;
@@ -347,7 +347,7 @@ static int free_contents(struct processing_module *mod, struct module_resource *
 
 	switch (container->type) {
 	case MOD_RES_HEAP:
-		sof_heap_free(res->alloc.heap, container->ptr);
+		sof_heap_free(res->alloc->heap, container->ptr);
 		res->heap_usage -= container->size;
 		return 0;
 #if CONFIG_COMP_BLOB
@@ -362,7 +362,7 @@ static int free_contents(struct processing_module *mod, struct module_resource *
 #else
 		mdom = NULL;
 #endif
-		fast_put(res->alloc.heap, mdom, container->sram_ptr);
+		fast_put(res->alloc->heap, mdom, container->sram_ptr);
 		return 0;
 #endif
 	default:
@@ -429,7 +429,7 @@ const void *z_vrfy_mod_fast_get(struct processing_module *mod, const void * cons
 	struct module_resources *res = &mod->priv.resources;
 
 	K_OOPS(K_SYSCALL_MEMORY_WRITE(mod, sizeof(*mod)));
-	K_OOPS(K_SYSCALL_MEMORY_WRITE(res->alloc.heap, sizeof(*res->alloc.heap)));
+	K_OOPS(K_SYSCALL_MEMORY_WRITE(res->alloc->heap, sizeof(*res->alloc->heap)));
 	K_OOPS(K_SYSCALL_MEMORY_READ(dram_ptr, size));
 
 	return z_impl_mod_fast_get(mod, dram_ptr, size);
@@ -443,7 +443,7 @@ void *z_vrfy_mod_alloc_ext(struct processing_module *mod, uint32_t flags, size_t
 	struct module_resources *res = &mod->priv.resources;
 
 	K_OOPS(K_SYSCALL_MEMORY_WRITE(mod, sizeof(*mod)));
-	K_OOPS(K_SYSCALL_MEMORY_WRITE(res->alloc.heap, sizeof(*res->alloc.heap)));
+	K_OOPS(K_SYSCALL_MEMORY_WRITE(res->alloc->heap, sizeof(*res->alloc->heap)));
 
 	return z_impl_mod_alloc_ext(mod, flags, size, alignment);
 }
@@ -454,7 +454,7 @@ int z_vrfy_mod_free(struct processing_module *mod, const void *ptr)
 	struct module_resources *res = &mod->priv.resources;
 
 	K_OOPS(K_SYSCALL_MEMORY_WRITE(mod, sizeof(*mod)));
-	K_OOPS(K_SYSCALL_MEMORY_WRITE(res->alloc.heap, sizeof(*res->alloc.heap)));
+	K_OOPS(K_SYSCALL_MEMORY_WRITE(res->alloc->heap, sizeof(*res->alloc->heap)));
 
 	return z_impl_mod_free(mod, ptr);
 }

src/audio/module_adapter/module_adapter.c

@@ -57,8 +57,8 @@ struct comp_dev *module_adapter_new(const struct comp_driver *drv,
 #define PAGE_SZ HOST_PAGE_SIZE
 #endif
 
-static struct dp_heap_user *module_adapter_dp_heap_new(const struct comp_ipc_config *config,
-						       size_t *heap_size)
+static struct k_heap *module_adapter_dp_heap_new(const struct comp_ipc_config *config,
+						 size_t *heap_size)
 {
 	/* src-lite with 8 channels has been seen allocating 14k in one go */
 	/* FIXME: the size will be derived from configuration */
@@ -71,9 +71,8 @@ static struct dp_heap_user *module_adapter_dp_heap_new(const struct comp_ipc_con
 	if (!mod_heap_mem)
 		return NULL;
 
-	struct dp_heap_user *mod_heap_user = (struct dp_heap_user *)mod_heap_mem;
-	struct k_heap *mod_heap = &mod_heap_user->heap;
-	const size_t heap_prefix_size = ALIGN_UP(sizeof(*mod_heap_user), 4);
+	struct k_heap *mod_heap = (struct k_heap *)mod_heap_mem;
+	const size_t heap_prefix_size = ALIGN_UP(sizeof(*mod_heap), 4);
 	void *mod_heap_buf = mod_heap_mem + heap_prefix_size;
 
 	*heap_size = buf_size - heap_prefix_size;
@@ -83,7 +82,7 @@ static struct dp_heap_user *module_adapter_dp_heap_new(const struct comp_ipc_con
 	mod_heap->heap.init_bytes = *heap_size;
 #endif
 
-	return mod_heap_user;
+	return mod_heap;
 }
 
 static struct processing_module *module_adapter_mem_alloc(const struct comp_driver *drv,
@@ -99,20 +98,17 @@ static struct processing_module *module_adapter_mem_alloc(const struct comp_driv
 	 */
 	uint32_t flags = config->proc_domain == COMP_PROCESSING_DOMAIN_DP ?
 		SOF_MEM_FLAG_USER | SOF_MEM_FLAG_COHERENT : SOF_MEM_FLAG_USER;
-	struct dp_heap_user *mod_heap_user;
 	size_t heap_size;
 
 	if (config->proc_domain == COMP_PROCESSING_DOMAIN_DP && IS_ENABLED(CONFIG_USERSPACE) &&
 	    !IS_ENABLED(CONFIG_SOF_USERSPACE_USE_DRIVER_HEAP)) {
-		mod_heap_user = module_adapter_dp_heap_new(config, &heap_size);
-		if (!mod_heap_user) {
+		mod_heap = module_adapter_dp_heap_new(config, &heap_size);
+		if (!mod_heap) {
 			comp_cl_err(drv, "Failed to allocate DP module heap");
 			return NULL;
 		}
-		mod_heap = &mod_heap_user->heap;
 	} else {
 		mod_heap = drv->user_heap;
-		mod_heap_user = NULL;
 		heap_size = 0;
 	}
 
@@ -123,9 +119,16 @@ static struct processing_module *module_adapter_mem_alloc(const struct comp_driv
 		goto emod;
 	}
 
+	struct mod_alloc_ctx *alloc = rmalloc(flags, sizeof(*alloc));
+
+	if (!alloc)
+		goto ealloc;
+
 	memset(mod, 0, sizeof(*mod));
-	mod->priv.resources.alloc.heap = mod_heap;
-	mod->priv.resources.alloc.client = mod_heap_user;
+	alloc->heap = mod_heap;
+	alloc->vreg = NULL;
+	alloc->client_count = 0;
+	mod->priv.resources.alloc = alloc;
 	mod_resource_init(mod);
 
 	/*
@@ -138,7 +141,7 @@ static struct processing_module *module_adapter_mem_alloc(const struct comp_driv
 
 	if (!dev) {
 		comp_cl_err(drv, "failed to allocate memory for comp_dev");
-		goto err;
+		goto edev;
 	}
 
 	memset(dev, 0, sizeof(*dev));
@@ -147,22 +150,25 @@ static struct processing_module *module_adapter_mem_alloc(const struct comp_driv
 	mod->dev = dev;
 	dev->mod = mod;
 
-	if (mod_heap_user)
-		mod_heap_user->client_count++;
+	if (config->proc_domain == COMP_PROCESSING_DOMAIN_DP)
+		alloc->client_count++;
 
 	return mod;
 
-err:
+edev:
+	rfree(alloc);
+ealloc:
 	sof_heap_free(mod_heap, mod);
 emod:
-	rfree(mod_heap_user);
+	rfree(mod_heap);
 
 	return NULL;
 }
 
 static void module_adapter_mem_free(struct processing_module *mod)
 {
-	struct k_heap *mod_heap = mod->priv.resources.alloc.heap;
+	struct mod_alloc_ctx *alloc = mod->priv.resources.alloc;
+	struct k_heap *mod_heap = alloc->heap;
 	unsigned int domain = mod->dev->ipc_config.proc_domain;
 
 	/*
@@ -175,11 +181,12 @@ static void module_adapter_mem_free(struct processing_module *mod)
 	sof_heap_free(mod_heap, mod->dev);
 	sof_heap_free(mod_heap, mod);
 	if (domain == COMP_PROCESSING_DOMAIN_DP) {
-		struct dp_heap_user *mod_heap_user = container_of(mod_heap, struct dp_heap_user,
-								  heap);
-
-		if (mod_heap && !--mod_heap_user->client_count)
-			rfree(mod_heap_user);
+		if (!IS_ENABLED(CONFIG_SOF_USERSPACE_USE_DRIVER_HEAP))
+			rfree(mod_heap);
+		if (!--alloc->client_count)
+			rfree(alloc);
+	} else {
+		rfree(alloc);
 	}
 }
 
@@ -612,7 +619,7 @@ int module_adapter_prepare(struct comp_dev *dev)
 	if (list_is_empty(&mod->raw_data_buffers_list)) {
 		for (i = 0; i < mod->num_of_sinks; i++) {
 			/* allocate not shared buffer */
-			struct comp_buffer *buffer = buffer_alloc(&md->resources.alloc,
+			struct comp_buffer *buffer = buffer_alloc(md->resources.alloc,
 								  buff_size, memory_flags,
 								  PLATFORM_DCACHE_ALIGN,
 								  BUFFER_USAGE_NOT_SHARED);
@@ -624,9 +631,9 @@ int module_adapter_prepare(struct comp_dev *dev)
 				goto free;
 			}
 
-			if (md->resources.alloc.heap &&
-			    md->resources.alloc.heap != dev->drv->user_heap)
-				md->resources.alloc.client->client_count++;
+			if (md->resources.alloc->heap &&
+			    md->resources.alloc->heap != dev->drv->user_heap)
+				md->resources.alloc->client_count++;
 
 			irq_local_disable(flags);
 			list_item_prepend(&buffer->buffers_list, &mod->raw_data_buffers_list);

src/audio/module_adapter/module_adapter_ipc4.c

@@ -147,7 +147,7 @@ int module_adapter_init_data(struct comp_dev *dev,
 		if (cfgsz == (sizeof(*cfg) + pinsz)) {
 			dst->nb_input_pins = n_in;
 			dst->nb_output_pins = n_out;
-			dst->input_pins = sof_heap_alloc(dev->mod->priv.resources.alloc.heap,
+			dst->input_pins = sof_heap_alloc(dev->mod->priv.resources.alloc->heap,
 							 SOF_MEM_FLAG_USER | SOF_MEM_FLAG_COHERENT,
 							 pinsz, 0);
 			if (!dst->input_pins)

src/include/sof/audio/component.h

@@ -580,11 +580,10 @@ struct comp_ops {
 
 struct k_heap;
 struct vregion;
-struct dp_heap_user;
 struct mod_alloc_ctx {
 	struct k_heap *heap;
 	struct vregion *vreg;
-	struct dp_heap_user *client;
+	unsigned int client_count;
 };
 
 /**

src/include/sof/audio/module_adapter/module/generic.h

@@ -132,7 +132,7 @@ struct module_resources {
 	struct objpool_head objpool;
 	size_t heap_usage;
 	size_t heap_high_water_mark;
-	struct mod_alloc_ctx alloc;
+	struct mod_alloc_ctx *alloc;
 #if CONFIG_MODULE_MEMORY_API_DEBUG && defined(__ZEPHYR__)
 	k_tid_t rsrc_mngr;
 #endif

src/include/sof/schedule/dp_schedule.h

@@ -119,12 +119,6 @@ union scheduler_dp_thread_ipc_param {
 	} pipeline_state;
 };
 
-struct dp_heap_user {
-	struct k_heap heap;
-	/* So far relying on linear processing of serialized IPCs, but might need protection */
-	unsigned int client_count;	/* devices and buffers */
-};
-
 #if CONFIG_ZEPHYR_DP_SCHEDULER
 int scheduler_dp_thread_ipc(struct processing_module *pmod, unsigned int cmd,
 			    const union scheduler_dp_thread_ipc_param *param);

src/ipc/ipc4/helper.c

@@ -659,7 +659,7 @@ __cold int ipc_comp_connect(struct ipc *ipc, ipc_pipe_comp_connect *_connect)
 	else
 		dp = NULL;
 
-	alloc = dp && dp->mod ? &dp->mod->priv.resources.alloc : NULL;
+	alloc = dp && dp->mod ? dp->mod->priv.resources.alloc : NULL;
 #else
 	alloc = NULL;
 #endif /* CONFIG_ZEPHYR_DP_SCHEDULER */
@@ -738,8 +738,8 @@ __cold int ipc_comp_connect(struct ipc *ipc, ipc_pipe_comp_connect *_connect)
 	}
 
 #if CONFIG_ZEPHYR_DP_SCHEDULER
-	if (alloc && alloc->client)
-		alloc->client->client_count++;
+	if (alloc)
+		alloc->client_count++;
 #endif
 
 	/*