pipeline: add alloc context object to pipeline

Replace the bare vregion pointer in struct pipeline with a
mod_alloc_ctx object that bundles both the optional vregion and the
heap pointer. The alloc context is always created in pipeline_new()
and freed symmetrically in pipeline_free(), removing the separate
cleanup that was in ipc_pipeline_free().

The pipeline object itself is now allocated through sof_ctx_zalloc()
so it resides in the vregion when one is available, falling back to
the default heap otherwise.

LL modules share the pipeline's alloc context instead of only
sharing the raw vregion pointer. A use_ppl_alloc flag gates the
sharing to LL modules only, so DP modules continue to create their
own vregion and alloc context as before.

module_adapter_mem_free() detects whether a module's alloc belongs
to its pipeline and either just releases the vregion reference
(ppl_alloc case) or tears down the module's own alloc.

Signed-off-by: Jyri Sarha <jyri.sarha@linux.intel.com>

Author: Jyri Sarha

src/audio/module_adapter/module_adapter.c

@@ -89,7 +89,7 @@ static
 struct processing_module *module_adapter_mem_alloc(const struct comp_driver *drv,
 						   const struct comp_ipc_config *config,
 						   const struct module_ext_init_data *ext_init,
-						   struct vregion *ppl_vreg)
+						   struct mod_alloc_ctx *ppl_alloc)
 {
 	struct k_heap *mod_heap;
 	struct vregion *mod_vreg;
@@ -105,6 +105,8 @@ struct processing_module *module_adapter_mem_alloc(const struct comp_driver *drv
 	uint32_t flags = config->proc_domain == COMP_PROCESSING_DOMAIN_DP ?
 		SOF_MEM_FLAG_USER | SOF_MEM_FLAG_COHERENT : SOF_MEM_FLAG_USER;
 	size_t heap_size;
+	bool use_ppl_alloc = ppl_alloc &&
+			     config->proc_domain == COMP_PROCESSING_DOMAIN_LL;
 
 	if (config->proc_domain == COMP_PROCESSING_DOMAIN_DP && IS_ENABLED(CONFIG_SOF_VREGIONS) &&
 	    IS_ENABLED(CONFIG_USERSPACE) && !IS_ENABLED(CONFIG_SOF_USERSPACE_USE_DRIVER_HEAP)) {
@@ -114,36 +116,47 @@ struct processing_module *module_adapter_mem_alloc(const struct comp_driver *drv
 			return NULL;
 		}
 		mod_heap = NULL;
-	} else if (ppl_vreg && config->proc_domain == COMP_PROCESSING_DOMAIN_LL) {
-		mod_vreg = vregion_get(ppl_vreg);
-		mod_heap = NULL;
+	} else if (use_ppl_alloc) {
+		mod_vreg = ppl_alloc->vreg ? vregion_get(ppl_alloc->vreg) : NULL;
+		mod_heap = ppl_alloc->heap;
 		heap_size = 0;
 	} else {
 		mod_heap = drv->user_heap;
 		heap_size = 0;
 		mod_vreg = NULL;
 	}
 
-	if (!mod_vreg)
+	if (use_ppl_alloc) {
+		/* LL modules use the pipeline's alloc context */
+		mod = sof_ctx_alloc(ppl_alloc, flags, sizeof(*mod), 0);
+	} else if (!mod_vreg) {
 		mod = sof_heap_alloc(mod_heap, flags, sizeof(*mod), 0);
-	else if (flags & SOF_MEM_FLAG_COHERENT)
+	} else if (flags & SOF_MEM_FLAG_COHERENT) {
 		mod = vregion_alloc_coherent(mod_vreg, sizeof(*mod));
-	else
+	} else {
 		mod = vregion_alloc(mod_vreg, sizeof(*mod));
+	}
 
 	if (!mod) {
 		comp_cl_err(drv, "failed to allocate memory for module");
 		goto emod;
 	}
 
-	struct mod_alloc_ctx *alloc = rzalloc(flags, sizeof(*alloc));
+	struct mod_alloc_ctx *alloc;
+
+	if (use_ppl_alloc) {
+		/* LL modules share the pipeline's alloc context */
+		alloc = ppl_alloc;
+	} else {
+		alloc = rzalloc(flags, sizeof(*alloc));
+		if (!alloc)
+			goto ealloc;
 
-	if (!alloc)
-		goto ealloc;
+		alloc->heap = mod_heap;
+		alloc->vreg = mod_vreg;
+	}
 
 	memset(mod, 0, sizeof(*mod));
-	alloc->heap = mod_heap;
-	alloc->vreg = mod_vreg;
 	mod->priv.resources.alloc = alloc;
 	mod_resource_init(mod);
 
@@ -153,7 +166,9 @@ struct processing_module *module_adapter_mem_alloc(const struct comp_driver *drv
 	 * then it can be cached. Effectively it can be only cached in
 	 * single-core configurations.
 	 */
-	if (mod_vreg)
+	if (use_ppl_alloc)
+		dev = sof_ctx_alloc(ppl_alloc, SOF_MEM_FLAG_COHERENT, sizeof(*dev), 0);
+	else if (mod_vreg)
 		dev = vregion_alloc_coherent(mod_vreg, sizeof(*dev));
 	else
 		dev = sof_heap_alloc(mod_heap, SOF_MEM_FLAG_COHERENT, sizeof(*dev), 0);
@@ -172,42 +187,47 @@ struct processing_module *module_adapter_mem_alloc(const struct comp_driver *drv
 	return mod;
 
 edev:
-	rfree(alloc);
+	if (!use_ppl_alloc)
+		rfree(alloc);
 ealloc:
-	if (mod_vreg)
+	if (use_ppl_alloc)
+		sof_ctx_free(ppl_alloc, mod);
+	else if (mod_vreg)
 		vregion_free(mod_vreg, mod);
 	else
 		sof_heap_free(mod_heap, mod);
 emod:
-	vregion_put(mod_vreg);
+	if (use_ppl_alloc)
+		vregion_put(ppl_alloc->vreg);
+	else
+		vregion_put(mod_vreg);
 
 	return NULL;
 }
 
 static void module_adapter_mem_free(struct processing_module *mod)
 {
 	struct mod_alloc_ctx *alloc = mod->priv.resources.alloc;
-	struct k_heap *mod_heap = alloc->heap;
+	bool ppl_alloc = mod->dev->ipc_config.proc_domain == COMP_PROCESSING_DOMAIN_LL &&
+			 mod->dev->pipeline && mod->dev->pipeline->alloc == alloc;
 
 	/*
 	 * In principle it shouldn't even be needed to free individual objects
 	 * on the module heap since we're freeing the heap itself too
 	 */
 #if CONFIG_IPC_MAJOR_4
-	sof_heap_free(mod_heap, mod->priv.cfg.input_pins);
+	sof_heap_free(alloc->heap, mod->priv.cfg.input_pins);
 #endif
-	if (alloc->vreg) {
-		struct vregion *mod_vreg = alloc->vreg;
-		uint32_t proc_domain = mod->dev->ipc_config.proc_domain;
-
-		vregion_free(mod_vreg, mod->dev);
-		vregion_free(mod_vreg, mod);
-		/* DP module alloc is freed later, but for LL modules we free it here */
-		if (!vregion_put(mod_vreg) || proc_domain == COMP_PROCESSING_DOMAIN_LL)
+	sof_ctx_free(alloc, mod->dev);
+	sof_ctx_free(alloc, mod);
+
+	if (ppl_alloc) {
+		/* alloc belongs to pipeline, just release vregion reference */
+		vregion_put(alloc->vreg);
+	} else if (alloc->vreg) {
+		if (!vregion_put(alloc->vreg))
 			rfree(alloc);
 	} else {
-		sof_heap_free(mod_heap, mod->dev);
-		sof_heap_free(mod_heap, mod);
 		rfree(alloc);
 	}
 }
@@ -261,18 +281,18 @@ struct comp_dev *module_adapter_new_ext(const struct comp_driver *drv,
 #if CONFIG_IPC_MAJOR_4
 	struct ipc_comp_dev *ipc_pipe;
 	struct ipc *ipc = ipc_get();
-	struct vregion *ppl_vreg = NULL;
+	struct mod_alloc_ctx *ppl_alloc = NULL;
 
-	/* resolve the pipeline pointer early to pass its vregion to mem_alloc */
+	/* resolve the pipeline pointer early to pass its alloc to mem_alloc */
 	ipc_pipe = ipc_get_comp_by_ppl_id(ipc, COMP_TYPE_PIPELINE, config->pipeline_id,
 					  IPC_COMP_IGNORE_REMOTE);
 	if (ipc_pipe && ipc_pipe->pipeline)
-		ppl_vreg = ipc_pipe->pipeline->vreg;
+		ppl_alloc = ipc_pipe->pipeline->alloc;
 #endif
 
 	struct processing_module *mod = module_adapter_mem_alloc(drv, config, ext_init,
 #if CONFIG_IPC_MAJOR_4
-								 ppl_vreg
+								 ppl_alloc
 #else
 								 NULL
 #endif

src/audio/pipeline/pipeline-graph.c

@@ -115,6 +115,7 @@ void pipeline_posn_init(struct sof *sof)
 struct pipeline *pipeline_new(struct k_heap *heap, uint32_t pipeline_id, uint32_t priority,
 			      uint32_t comp_id, struct create_pipeline_params *pparams)
 {
+	struct mod_alloc_ctx *alloc;
 	struct sof_ipc_stream_posn posn;
 	struct pipeline *p;
 	int ret;
@@ -125,17 +126,13 @@ struct pipeline *pipeline_new(struct k_heap *heap, uint32_t pipeline_id, uint32_
 	/* show heap status */
 	heap_trace_all(0);
 
-	/* allocate new pipeline */
-	p = sof_heap_alloc(heap, SOF_MEM_FLAG_USER, sizeof(*p), 0);
-	if (!p) {
-		pipe_cl_err("Out of Memory");
+	alloc = rzalloc(SOF_MEM_FLAG_USER, sizeof(*alloc));
+	if (!alloc) {
+		pipe_cl_err("Failed to allocate pipeline alloc context");
 		return NULL;
 	}
 
-	memset(p, 0, sizeof(*p));
-
-	/* init pipeline */
-	p->heap = heap;
+	alloc->heap = heap;
 
 	/* Create vregion for pipeline and its modules if size info is available */
 	if (IS_ENABLED(CONFIG_SOF_VREGIONS) &&
@@ -146,6 +143,16 @@ struct pipeline *pipeline_new(struct k_heap *heap, uint32_t pipeline_id, uint32_
 				    pparams->mem_data->heap_bytes);
 	}
 
+	p = sof_ctx_zalloc(alloc, SOF_MEM_FLAG_USER, sizeof(*p), 0);
+	if (!p) {
+		pipe_cl_err("Out of Memory");
+		goto free_alloc;
+	}
+
+	/* init pipeline */
+	p->heap = heap;
+	p->alloc = alloc;
+
 	p->comp_id = comp_id;
 	p->priority = priority;
 	p->pipeline_id = pipeline_id;
@@ -178,7 +185,10 @@ struct pipeline *pipeline_new(struct k_heap *heap, uint32_t pipeline_id, uint32_
 
 	return p;
 free:
-	sof_heap_free(heap, p);
+	sof_ctx_free(alloc, p);
+free_alloc:
+	vregion_put(alloc->vreg);
+	rfree(alloc);
 	return NULL;
 }
 
@@ -251,6 +261,8 @@ void pipeline_disconnect(struct comp_dev *comp, struct comp_buffer *buffer, int
 /* pipelines must be inactive */
 int pipeline_free(struct pipeline *p)
 {
+	struct mod_alloc_ctx *alloc = p->alloc;
+
 	pipe_dbg(p, "entry");
 
 	/*
@@ -271,7 +283,12 @@ int pipeline_free(struct pipeline *p)
 	pipeline_posn_offset_put(p->posn_offset);
 
 	/* now free the pipeline */
-	sof_heap_free(p->heap, p);
+	sof_ctx_free(alloc, p);
+
+	/* free alloc context and vregion */
+	if (vregion_put(alloc->vreg))
+		pipe_cl_warn("pipeline vregion still in use");
+	rfree(alloc);
 
 	/* show heap status */
 	heap_trace_all(0);
@@ -349,8 +366,8 @@ int pipeline_complete(struct pipeline *p, struct comp_dev *source,
 	p->source_comp = source;
 	p->sink_comp = sink;
 
-	if (p->vreg)
-		vregion_set_interim(p->vreg);
+	if (p->alloc && p->alloc->vreg)
+		vregion_set_interim(p->alloc->vreg);
 
 	p->status = COMP_STATE_READY;
 

src/include/sof/audio/pipeline.h

@@ -26,7 +26,7 @@ struct comp_dev;
 struct ipc;
 struct ipc_msg;
 struct k_heap;
-struct vregion;
+struct mod_alloc_ctx;
 
 /*
  * Pipeline status to stop execution of current path, but to keep the
@@ -55,7 +55,7 @@ struct vregion;
  */
 struct pipeline {
 	struct k_heap *heap;	/**< heap used for allocating this pipeline */
-	struct vregion *vreg;	/**< shared vregion for pipeline modules */
+	struct mod_alloc_ctx *alloc;	/**< shared alloc context for pipeline modules */
 	uint32_t comp_id;	/**< component id for pipeline */
 	uint32_t pipeline_id;	/**< pipeline id */
 	uint32_t sched_id;	/**< Scheduling component id */

src/ipc/ipc4/helper.c

@@ -513,11 +513,6 @@ __cold int ipc_pipeline_free(struct ipc *ipc, uint32_t comp_id)
 		return ret;
 	}
 
-	if (ipc_pipe->pipeline->vreg) {
-		if (vregion_put(ipc_pipe->pipeline->vreg))
-			tr_warn(&ipc_tr, "pipeline vregion still in use");
-	}
-
 	/* free buffer, delete all tasks and remove from list */
 	ret = pipeline_free(ipc_pipe->pipeline);
 	if (ret < 0) {