lib: vregion: lazy interim heap creation from remaining lifetime space

Refactor the vregion memory layout to use a single contiguous buffer
instead of two separately page-aligned partitions. The vregion
lifetime allocations start at the base and growing upward. The interim
k_heap is created lazily when vregion_set_interim() is called
for whatever space remains after lifetime allocations.

This eliminates the rigid partition boundary that previously wasted
memory when lifetime usage was smaller or larger than pre-configured.
The interim heap creation is deferred until actually needed, at which
point the lifetime region is sealed and any further allocation
requests are redirected to the interim.

The vregion tracks internal allocation mode (lifetime or interim).
All allocations start in lifetime mode. The vregion_set_interim()
function switches to interim mode. The enum vregion_mem_type parameter
has been removed from the vregion_alloc*() API since the mode is now
internal state.

vregion_set_interim() is called in pipeline_comp_complete() in case
the component's processing domain is Data Processing. The DP
components are so far the only place where vregions are used at the
moment.

Add a guard to skip k_heap_init() in interim_heap_init() if the
remaining interim size is too small (< 1024 bytes), which would
otherwise trigger an assert failure in sys_heap_init(). Mark the
vregion type to VREGION_MEM_TYPE_INVALID if that happens.

Key changes:
- vregion_create(): Takes single memsize argument instead of separate
  lifetime_size and interim_size
- New vregion_set_interim(): Switches allocation mode from lifetime to
  interim, warns on repeated calls
- vregion_alloc*(): No longer take enum vregion_mem_type parameter,
  use internal state instead
- New interim_heap_init(): Called lazily, page-aligns interim start,
  logs lifetime used and interim available at INFO level
- vregion_free(): Guards interim pointer range
- pipeline_comp_completee(): Calls vregion_set_interim() to switch mode

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

Author: Jyri Sarha

src/audio/module_adapter/module_adapter.c

@@ -65,13 +65,7 @@ static struct vregion *module_adapter_dp_heap_new(const struct comp_ipc_config *
 	/* FIXME: the size will be derived from configuration */
 	const size_t buf_size = 28 * 1024;
 
-	/*
-	 * A 1-to-1 replacement of the original heap implementation would be to
-	 * have "lifetime size" equal to 0. But (1) this is invalid for
-	 * vregion_create() and (2) we gradually move objects, that are simple
-	 * to move to the lifetime buffer. Make it 4k for the beginning.
-	 */
-	return vregion_create(4096, buf_size - 4096);
+	return vregion_create(buf_size);
 }
 
 static struct processing_module *module_adapter_mem_alloc(const struct comp_driver *drv,
@@ -109,9 +103,9 @@ static struct processing_module *module_adapter_mem_alloc(const struct comp_driv
 	if (!mod_vreg)
 		mod = sof_heap_alloc(mod_heap, flags, sizeof(*mod), 0);
 	else if (flags & SOF_MEM_FLAG_COHERENT)
-		mod = vregion_alloc_coherent(mod_vreg, VREGION_MEM_TYPE_LIFETIME, sizeof(*mod));
+		mod = vregion_alloc_coherent(mod_vreg, sizeof(*mod));
 	else
-		mod = vregion_alloc(mod_vreg, VREGION_MEM_TYPE_LIFETIME, sizeof(*mod));
+		mod = vregion_alloc(mod_vreg, sizeof(*mod));
 
 	if (!mod) {
 		comp_cl_err(drv, "failed to allocate memory for module");
@@ -136,7 +130,7 @@ static struct processing_module *module_adapter_mem_alloc(const struct comp_driv
 	 * single-core configurations.
 	 */
 	if (mod_vreg)
-		dev = vregion_alloc_coherent(mod_vreg, VREGION_MEM_TYPE_LIFETIME, sizeof(*dev));
+		dev = vregion_alloc_coherent(mod_vreg, sizeof(*dev));
 	else
 		dev = sof_heap_alloc(mod_heap, SOF_MEM_FLAG_COHERENT, sizeof(*dev), 0);
 

src/audio/pipeline/pipeline-graph.c

@@ -7,8 +7,10 @@
 
 #include <sof/audio/buffer.h>
 #include <sof/audio/component_ext.h>
+#include <sof/audio/module_adapter/module/generic.h>
 #include <sof/audio/pipeline.h>
 #include <sof/ipc/msg.h>
+#include <sof/lib/vregion.h>
 #include <rtos/interrupt.h>
 #include <rtos/symbol.h>
 #include <rtos/alloc.h>
@@ -294,8 +296,14 @@ static int pipeline_comp_complete(struct comp_dev *current,
 	 * It will be calculated during module prepare operation
 	 * either by the module or to default value based on module's OBS
 	 */
-	if (current->ipc_config.proc_domain == COMP_PROCESSING_DOMAIN_LL)
+	if (current->ipc_config.proc_domain == COMP_PROCESSING_DOMAIN_LL) {
 		current->period = ppl_data->p->period;
+	} else {
+		struct processing_module *mod = comp_mod(current);
+
+		if (mod && mod->priv.resources.alloc)
+			vregion_set_interim(mod->priv.resources.alloc->vreg);
+	}
 
 	current->priority = ppl_data->p->priority;
 

src/include/sof/lib/vregion.h

@@ -24,21 +24,32 @@ struct vregion;
 enum vregion_mem_type {
 	VREGION_MEM_TYPE_INTERIM,		/* interim allocation that can be freed */
 	VREGION_MEM_TYPE_LIFETIME,		/* lifetime allocation */
+	VREGION_MEM_TYPE_INVALID,		/* Interim heap initialization failed */
 };
 
 #if CONFIG_SOF_VREGIONS
 
 /**
  * @brief Create a new virtual region instance.
  *
- * Create a new virtual region instance with specified static and dynamic partitions.
- * Total size is the sum of static and dynamic sizes.
+ * Create a new virtual region instance with specified memory size.
+ * Allocations start in LIFETIME mode.
  *
- * @param[in] lifetime_size Size of the virtual region lifetime partition.
- * @param[in] interim_size Size of the virtual region interim partition.
+ * @param[in] memsize Total size of the virtual region memory.
  * @return struct vregion* Pointer to the new virtual region instance, or NULL on failure.
  */
-struct vregion *vregion_create(size_t lifetime_size, size_t interim_size);
+struct vregion *vregion_create(size_t memsize);
+
+/**
+ * @brief Switch virtual region allocations to interim mode.
+ *
+ * After this call, all allocations from this vregion will use the interim
+ * heap. The interim heap is created lazily from remaining lifetime space.
+ * Multiple calls are allowed but log a warning.
+ *
+ * @param[in] vr Pointer to the virtual region instance.
+ */
+void vregion_set_interim(struct vregion *vr);
 
 /**
  * @brief Increment virtual region's user count.
@@ -66,36 +77,33 @@ struct vregion *vregion_put(struct vregion *vr);
  * @brief Allocate memory from the specified virtual region.
  *
  * @param[in] vr Pointer to the virtual region instance.
- * @param[in] type Type of memory to allocate (lifetime or interim).
  * @param[in] size Size of memory to allocate in bytes.
  * @return void* Pointer to the allocated memory, or NULL on failure.
  */
-void *vregion_alloc(struct vregion *vr, enum vregion_mem_type type, size_t size);
+void *vregion_alloc(struct vregion *vr, size_t size);
 
 /**
  * @brief like vregion_alloc() but allocates coherent memory
  */
-void *vregion_alloc_coherent(struct vregion *vr, enum vregion_mem_type type, size_t size);
+void *vregion_alloc_coherent(struct vregion *vr, size_t size);
 
 /**
  * @brief Allocate aligned memory from the specified virtual region.
  *
- * Allocate aligned memory from the specified virtual region based on the memory type.
+ * Allocate aligned memory from the specified virtual region using the
+ * current allocation mode (lifetime or interim).
  *
  * @param[in] vr Pointer to the virtual region instance.
- * @param[in] type Type of memory to allocate (lifetime or interim).
  * @param[in] size Size of memory to allocate in bytes.
  * @param[in] alignment Alignment of memory to allocate in bytes.
  * @return void* Pointer to the allocated memory, or NULL on failure.
  */
-void *vregion_alloc_align(struct vregion *vr, enum vregion_mem_type type,
-			  size_t size, size_t alignment);
+void *vregion_alloc_align(struct vregion *vr, size_t size, size_t alignment);
 
 /**
  * @brief like vregion_alloc_align() but allocates coherent memory
  */
-void *vregion_alloc_coherent_align(struct vregion *vr, enum vregion_mem_type type,
-				   size_t size, size_t alignment);
+void *vregion_alloc_coherent_align(struct vregion *vr, size_t size, size_t alignment);
 
 /**
  * @brief Free memory allocated from the specified virtual region.
@@ -129,10 +137,11 @@ struct vregion {
 	unsigned int use_count;
 };
 
-static inline struct vregion *vregion_create(size_t lifetime_size, size_t interim_size)
+static inline struct vregion *vregion_create(size_t memsize)
 {
 	return NULL;
 }
+static inline void vregion_set_interim(struct vregion *vr) {}
 static inline struct vregion *vregion_get(struct vregion *vr)
 {
 	return vr;
@@ -141,22 +150,20 @@ static inline struct vregion *vregion_put(struct vregion *vr)
 {
 	return vr;
 }
-static inline void *vregion_alloc(struct vregion *vr, enum vregion_mem_type type, size_t size)
+static inline void *vregion_alloc(struct vregion *vr, size_t size)
 {
 	return NULL;
 }
-static inline void *vregion_alloc_coherent(struct vregion *vr, enum vregion_mem_type type,
-					   size_t size)
+static inline void *vregion_alloc_coherent(struct vregion *vr, size_t size)
 {
 	return NULL;
 }
-static inline void *vregion_alloc_align(struct vregion *vr, enum vregion_mem_type type,
-					size_t size, size_t alignment)
+static inline void *vregion_alloc_align(struct vregion *vr, size_t size, size_t alignment)
 {
 	return NULL;
 }
-static inline void *vregion_alloc_coherent_align(struct vregion *vr, enum vregion_mem_type type,
-						 size_t size, size_t alignment)
+static inline void *vregion_alloc_coherent_align(struct vregion *vr, size_t size,
+						 size_t alignment)
 {
 	return NULL;
 }

src/lib/objpool.c

@@ -44,10 +44,10 @@ static int objpool_add(struct objpool_head *head, unsigned int n, size_t size, u
 		pobjpool = sof_heap_alloc(head->heap, flags,
 					  aligned_size + sizeof(*pobjpool), 0);
 	else if (flags & SOF_MEM_FLAG_COHERENT)
-		pobjpool = vregion_alloc_coherent(head->vreg, VREGION_MEM_TYPE_INTERIM,
+		pobjpool = vregion_alloc_coherent(head->vreg,
 						  aligned_size + sizeof(*pobjpool));
 	else
-		pobjpool = vregion_alloc(head->vreg, VREGION_MEM_TYPE_INTERIM,
+		pobjpool = vregion_alloc(head->vreg,
 					 aligned_size + sizeof(*pobjpool));
 
 	if (!pobjpool)

zephyr/include/rtos/alloc.h

@@ -189,10 +189,9 @@ static inline void *sof_ctx_alloc(struct mod_alloc_ctx *ctx, uint32_t flags,
 		return sof_heap_alloc(ctx ? ctx->heap : NULL, flags, size, alignment);
 
 	if (flags & SOF_MEM_FLAG_COHERENT)
-		return vregion_alloc_coherent_align(ctx->vreg, VREGION_MEM_TYPE_INTERIM,
-						    size, alignment);
+		return vregion_alloc_coherent_align(ctx->vreg, size, alignment);
 
-	return vregion_alloc_align(ctx->vreg, VREGION_MEM_TYPE_INTERIM, size, alignment);
+	return vregion_alloc_align(ctx->vreg, size, alignment);
 }
 
 /**

zephyr/lib/fast-get.c

@@ -203,7 +203,7 @@ const void *fast_get(struct mod_alloc_ctx *alloc, const void *dram_ptr, size_t s
 
 	if (alloc && alloc->vreg && size <= FAST_GET_MAX_COPY_SIZE)
 		/* A userspace allocation, that won't be shared */
-		ret = vregion_alloc_align(alloc->vreg, VREGION_MEM_TYPE_INTERIM, alloc_size,
+		ret = vregion_alloc_align(alloc->vreg, alloc_size,
 					  alloc_align);
 	else
 		ret = sof_heap_alloc(heap, alloc_flags, alloc_size, alloc_align);