diff --git a/src/audio/mfcc/mfcc.c b/src/audio/mfcc/mfcc.c
index 6437c187e29e..547e86850213 100644
--- a/src/audio/mfcc/mfcc.c
+++ b/src/audio/mfcc/mfcc.c
@@ -88,44 +88,32 @@ static int mfcc_init(struct processing_module *mod)
 		return -EINVAL;
 	}
 
-	cd = rzalloc(SOF_MEM_FLAG_USER, sizeof(*cd));
+	cd = mod_zalloc(mod, sizeof(*cd));
 	if (!cd)
 		return -ENOMEM;
 
 	/* Handler for configuration data */
 	md->private = cd;
-	cd->model_handler = comp_data_blob_handler_new(dev);
+	cd->model_handler = mod_data_blob_handler_new(mod);
 	if (!cd->model_handler) {
 		comp_err(dev, "comp_data_blob_handler_new() failed.");
-		ret = -ENOMEM;
-		goto err;
+		return -ENOMEM;
 	}
 
 	/* Get configuration data */
 	ret = comp_init_data_blob(cd->model_handler, bs, cfg->init_data);
 	if (ret < 0) {
 		comp_err(mod->dev, "comp_init_data_blob() failed.");
-		goto err_init;
+		return ret;
 	}
 
 	return 0;
-
-err_init:
-	comp_data_blob_handler_free(cd->model_handler);
-
-err:
-	rfree(cd);
-	return ret;
 }
 
 static int mfcc_free(struct processing_module *mod)
 {
-	struct mfcc_comp_data *cd = module_get_private_data(mod);
-
 	comp_info(mod->dev, "mfcc_free()");
-	comp_data_blob_handler_free(cd->model_handler);
-	mfcc_free_buffers(cd);
-	rfree(cd);
+	mfcc_free_buffers(mod);
 	return 0;
 }
 
diff --git a/src/audio/mfcc/mfcc_setup.c b/src/audio/mfcc/mfcc_setup.c
index 802ea058bb6f..33d6577f9d38 100644
--- a/src/audio/mfcc/mfcc_setup.c
+++ b/src/audio/mfcc/mfcc_setup.c
@@ -65,7 +65,7 @@ static int mfcc_get_window(struct mfcc_state *state, enum sof_mfcc_fft_window_ty
  * coef[i] = 1.0 + 0.5 * lifter * sin(pi * i / lifter), i = 0 to num_ceps-1
  */
 
-static int mfcc_get_cepstral_lifter(struct mfcc_cepstral_lifter *cl)
+static int mfcc_get_cepstral_lifter(struct processing_module *mod, struct mfcc_cepstral_lifter *cl)
 {
 	int32_t inv_cepstral_lifter;
 	int32_t val;
@@ -75,7 +75,7 @@ static int mfcc_get_cepstral_lifter(struct mfcc_cepstral_lifter *cl)
 	if (cl->num_ceps > DCT_MATRIX_SIZE_MAX)
 		return -EINVAL;
 
-	cl->matrix = mat_matrix_alloc_16b(1, cl->num_ceps, 9); /* Use Q7.9 */
+	cl->matrix = mod_mat_matrix_alloc_16b(mod, 1, cl->num_ceps, 9); /* Use Q7.9 */
 	if (!cl->matrix)
 		return -ENOMEM;
 
@@ -171,12 +171,10 @@ int mfcc_setup(struct processing_module *mod, int max_frames, int sample_rate, i
 	comp_info(dev, "mfcc_setup(), buffer_size = %d, prev_size = %d",
 		  state->buffer_size, state->prev_data_size);
 
-	state->buffers = rzalloc(SOF_MEM_FLAG_USER,
-				 state->sample_buffers_size);
+	state->buffers = mod_zalloc(mod, state->sample_buffers_size);
 	if (!state->buffers) {
 		comp_err(dev, "Failed buffer allocate");
-		ret = -ENOMEM;
-		goto exit;
+		return -ENOMEM;
 	}
 
 	mfcc_init_buffer(&state->buf, state->buffers, state->buffer_size);
@@ -189,29 +187,26 @@ int mfcc_setup(struct processing_module *mod, int max_frames, int sample_rate, i
 #else
 	fft->fft_buffer_size = fft->fft_padded_size * sizeof(struct icomplex32);
 #endif
-	fft->fft_buf = rzalloc(SOF_MEM_FLAG_USER, fft->fft_buffer_size);
+	fft->fft_buf = mod_zalloc(mod, fft->fft_buffer_size);
 	if (!fft->fft_buf) {
 		comp_err(dev, "Failed FFT buffer allocate");
-		ret = -ENOMEM;
-		goto free_buffers;
+		return -ENOMEM;
 	}
 
-	fft->fft_out = rzalloc(SOF_MEM_FLAG_USER, fft->fft_buffer_size);
+	fft->fft_out = mod_zalloc(mod, fft->fft_buffer_size);
 	if (!fft->fft_out) {
 		comp_err(dev, "Failed FFT output allocate");
-		ret = -ENOMEM;
-		goto free_fft_buf;
+		return -ENOMEM;
 	}
 
 	fft->fft_fill_start_idx = 0; /* From config pad_type */
 
 	/* Setup FFT */
-	fft->fft_plan = fft_plan_new(fft->fft_buf, fft->fft_out, fft->fft_padded_size,
-				     MFCC_FFT_BITS);
+	fft->fft_plan = mod_fft_plan_new(mod, fft->fft_buf, fft->fft_out, fft->fft_padded_size,
+					 MFCC_FFT_BITS);
 	if (!fft->fft_plan) {
 		comp_err(dev, "Failed FFT init");
-		ret = -EINVAL;
-		goto free_fft_out;
+		return -EINVAL;
 	}
 
 	comp_info(dev, "mfcc_setup(), window = %d, num_mel_bins = %d, num_ceps = %d, norm = %d",
@@ -223,7 +218,7 @@ int mfcc_setup(struct processing_module *mod, int max_frames, int sample_rate, i
 	ret = mfcc_get_window(state, config->window);
 	if (ret < 0) {
 		comp_err(dev, "Failed Window function");
-		goto free_fft_out;
+		return ret;
 	}
 
 	/* Setup Mel auditory filterbank. FFT input and output buffers are used
@@ -242,10 +237,10 @@ int mfcc_setup(struct processing_module *mod, int max_frames, int sample_rate, i
 	fb->scratch_data2 = (int16_t *)fft->fft_out;
 	fb->scratch_length1 = fft->fft_buffer_size / sizeof(int16_t);
 	fb->scratch_length2 = fft->fft_buffer_size / sizeof(int16_t);
-	ret = psy_get_mel_filterbank(fb);
+	ret = mod_psy_get_mel_filterbank(mod, fb);
 	if (ret < 0) {
 		comp_err(dev, "Failed Mel filterbank");
-		goto free_fft_out;
+		return ret;
 	}
 
 	/* Setup DCT */
@@ -253,18 +248,18 @@ int mfcc_setup(struct processing_module *mod, int max_frames, int sample_rate, i
 	dct->num_out = config->num_ceps;
 	dct->type = (enum dct_type)config->dct;
 	dct->ortho = true;
-	ret = dct_initialize_16(dct);
+	ret = mod_dct_initialize_16(mod, dct);
 	if (ret < 0) {
 		comp_err(dev, "Failed DCT init");
-		goto free_melfb_data;
+		return ret;
 	}
 
 	state->lifter.num_ceps = config->num_ceps;
 	state->lifter.cepstral_lifter = config->cepstral_lifter; /* Q7.9 max 64.0*/
-	ret = mfcc_get_cepstral_lifter(&state->lifter);
+	ret = mfcc_get_cepstral_lifter(mod, &state->lifter);
 	if (ret < 0) {
 		comp_err(dev, "Failed cepstral lifter");
-		goto free_dct_matrix;
+		return ret;
 	}
 
 	/* Scratch overlay during runtime
@@ -297,33 +292,17 @@ int mfcc_setup(struct processing_module *mod, int max_frames, int sample_rate, i
 
 	comp_dbg(dev, "mfcc_setup(), done");
 	return 0;
-
-free_dct_matrix:
-	rfree(state->dct.matrix);
-
-free_melfb_data:
-	rfree(fb->data);
-
-free_fft_out:
-	rfree(fft->fft_out);
-
-free_fft_buf:
-	rfree(fft->fft_buf);
-
-free_buffers:
-	rfree(state->buffers);
-
-exit:
-	return ret;
 }
 
-void mfcc_free_buffers(struct mfcc_comp_data *cd)
+void mfcc_free_buffers(struct processing_module *mod)
 {
-	fft_plan_free(cd->state.fft.fft_plan);
-	rfree(cd->state.fft.fft_buf);
-	rfree(cd->state.fft.fft_out);
-	rfree(cd->state.buffers);
-	rfree(cd->state.melfb.data);
-	rfree(cd->state.dct.matrix);
-	rfree(cd->state.lifter.matrix);
+	struct mfcc_comp_data *cd = module_get_private_data(mod);
+
+	mod_fft_plan_free(mod, cd->state.fft.fft_plan);
+	mod_free(mod, cd->state.fft.fft_buf);
+	mod_free(mod, cd->state.fft.fft_out);
+	mod_free(mod, cd->state.buffers);
+	mod_free(mod, cd->state.melfb.data);
+	mod_free(mod, cd->state.dct.matrix);
+	mod_free(mod, cd->state.lifter.matrix);
 }
diff --git a/src/audio/module_adapter/Kconfig b/src/audio/module_adapter/Kconfig
index bb9081812271..3c762c73f7f8 100644
--- a/src/audio/module_adapter/Kconfig
+++ b/src/audio/module_adapter/Kconfig
@@ -3,6 +3,27 @@
 menu "Processing modules"
 	visible if COMP_MODULE_ADAPTER
 
+	config MODULE_MEMORY_API_CONTAINER_CHUNK_SIZE
+		int "Number of memory containers to allocate at once"
+		default 16
+		help
+		  The per module resource containers are allocated in
+		  chunks. The unused containers are kept in free
+		  list. When the free list is empty the amount of
+		  containers to allocate at once is selected by this
+		  config option.
+
+	config MODULE_MEMORY_API_DEBUG
+		bool "Turn on memory API thread safety checks"
+		default y if DEBUG
+		help
+		  The Module Memory API structures are not protected
+		  by locks. This is because the initialization,
+		  allocation, and freeing of resources should always
+		  be done in the same thread. This option adds an
+		  assert to make sure no other thread makes such
+		  operations.
+
 	config CADENCE_CODEC
 		bool "Cadence codec"
 		default n
diff --git a/src/audio/module_adapter/module/generic.c b/src/audio/module_adapter/module/generic.c
index 03a345552f71..cb4ea2e3d5ae 100644
--- a/src/audio/module_adapter/module/generic.c
+++ b/src/audio/module_adapter/module/generic.c
@@ -14,6 +14,16 @@
 #include <rtos/symbol.h>
 
 #include <sof/audio/module_adapter/module/generic.h>
+#include <sof/audio/data_blob.h>
+#include <sof/lib/fast-get.h>
+
+/* The __ZEPHYR__ condition is to keep cmocka tests working */
+#if CONFIG_MODULE_MEMORY_API_DEBUG && defined(__ZEPHYR__)
+#define MEM_API_CHECK_THREAD(res) __ASSERT((res)->rsrc_mngr == k_current_get(), \
+		"Module memory API operation from wrong thread")
+#else
+#define MEM_API_CHECK_THREAD(res)
+#endif
 
 LOG_MODULE_DECLARE(module_adapter, CONFIG_SOF_LOG_LEVEL);
 
@@ -92,8 +102,14 @@ int module_init(struct processing_module *mod)
 	}
 
 	/* Init memory list */
-	list_init(&md->memory.mem_list);
-
+	list_init(&md->resources.res_list);
+	list_init(&md->resources.free_cont_list);
+	list_init(&md->resources.cont_chunk_list);
+	md->resources.heap_usage = 0;
+	md->resources.heap_high_water_mark = 0;
+#if CONFIG_MODULE_MEMORY_API_DEBUG && defined(__ZEPHYR__)
+	md->resources.rsrc_mngr = k_current_get();
+#endif
 	/* Now we can proceed with module specific initialization */
 	ret = interface->init(mod);
 	if (ret) {
@@ -110,6 +126,42 @@ int module_init(struct processing_module *mod)
 	return 0;
 }
 
+struct container_chunk {
+	struct list_item chunk_list;
+	struct module_resource containers[CONFIG_MODULE_MEMORY_API_CONTAINER_CHUNK_SIZE];
+};
+
+static struct module_resource *container_get(struct processing_module *mod)
+{
+	struct module_resources *res = &mod->priv.resources;
+	struct module_resource *container;
+
+	if (list_is_empty(&res->free_cont_list)) {
+		struct container_chunk *chunk = rzalloc(SOF_MEM_FLAG_USER, sizeof(*chunk));
+		int i;
+
+		if (!chunk) {
+			comp_err(mod->dev, "allocating more containers failed");
+			return NULL;
+		}
+
+		list_item_append(&chunk->chunk_list, &res->cont_chunk_list);
+		for (i = 0; i < ARRAY_SIZE(chunk->containers); i++)
+			list_item_append(&chunk->containers[i].list, &res->free_cont_list);
+	}
+
+	container = list_first_item(&res->free_cont_list, struct module_resource, list);
+	list_item_del(&container->list);
+	return container;
+}
+
+static void container_put(struct processing_module *mod, struct module_resource *container)
+{
+	struct module_resources *res = &mod->priv.resources;
+
+	list_item_append(&container->list, &res->free_cont_list);
+}
+
 /**
  * Allocates aligned memory block for module.
  * @param mod		Pointer to the module this memory block is allocatd for.
@@ -121,20 +173,17 @@ int module_init(struct processing_module *mod)
  */
 void *mod_alloc_align(struct processing_module *mod, uint32_t size, uint32_t alignment)
 {
-	struct comp_dev *dev = mod->dev;
-	struct module_memory *container;
+	struct module_resource *container = container_get(mod);
+	struct module_resources *res = &mod->priv.resources;
 	void *ptr;
 
-	if (!size) {
-		comp_err(dev, "mod_alloc: requested allocation of 0 bytes.");
+	MEM_API_CHECK_THREAD(res);
+	if (!container)
 		return NULL;
-	}
 
-	/* Allocate memory container */
-	container = rzalloc(SOF_MEM_FLAG_USER,
-			    sizeof(struct module_memory));
-	if (!container) {
-		comp_err(dev, "mod_alloc: failed to allocate memory container.");
+	if (!size) {
+		comp_err(mod->dev, "mod_alloc: requested allocation of 0 bytes.");
+		container_put(mod, container);
 		return NULL;
 	}
 
@@ -145,15 +194,20 @@ void *mod_alloc_align(struct processing_module *mod, uint32_t size, uint32_t ali
 		ptr = rballoc(SOF_MEM_FLAG_USER, size);
 
 	if (!ptr) {
-		comp_err(dev, "mod_alloc: failed to allocate memory for comp %x.",
-			 dev_comp_id(dev));
-		rfree(container);
+		comp_err(mod->dev, "mod_alloc: failed to allocate memory for comp %x.",
+			 dev_comp_id(mod->dev));
+		container_put(mod, container);
 		return NULL;
 	}
 	/* Store reference to allocated memory */
 	container->ptr = ptr;
 	container->size = size;
-	list_item_prepend(&container->mem_list, &mod->priv.memory.mem_list);
+	container->type = MOD_RES_HEAP;
+	list_item_prepend(&container->list, &res->res_list);
+
+	res->heap_usage += size;
+	if (res->heap_usage > res->heap_high_water_mark)
+		res->heap_high_water_mark = res->heap_usage;
 
 	return ptr;
 }
@@ -193,28 +247,124 @@ void *mod_zalloc(struct processing_module *mod, uint32_t size)
 }
 EXPORT_SYMBOL(mod_zalloc);
 
+/**
+ * Creates a blob handler and releases it when the module is unloaded
+ * @param mod	Pointer to module this memory block is allocated for.
+ * @return Pointer to the created data blob handler
+ *
+ * Like comp_data_blob_handler_new() but the handler is automatically freed.
+ */
+#if CONFIG_COMP_BLOB
+struct comp_data_blob_handler *
+mod_data_blob_handler_new(struct processing_module *mod)
+{
+	struct module_resources *res = &mod->priv.resources;
+	struct module_resource *container = container_get(mod);
+	struct comp_data_blob_handler *bhp;
+
+	MEM_API_CHECK_THREAD(res);
+	if (!container)
+		return NULL;
+
+	bhp = comp_data_blob_handler_new_ext(mod->dev, false, NULL, NULL);
+	if (!bhp) {
+		container_put(mod, container);
+		return NULL;
+	}
+
+	container->bhp = bhp;
+	container->size = 0;
+	container->type = MOD_RES_BLOB_HANDLER;
+	list_item_prepend(&container->list, &res->res_list);
+
+	return bhp;
+}
+EXPORT_SYMBOL(mod_data_blob_handler_new);
+#endif
+
+/**
+ * Make a module associated shared SRAM copy of DRAM read-only data.
+ * @param mod	Pointer to module this copy is allocated for.
+ * @return Pointer to the SRAM copy.
+ *
+ * Like fast_get() but the handler is automatically freed.
+ */
+#if CONFIG_FAST_GET
+const void *mod_fast_get(struct processing_module *mod, const void * const dram_ptr, size_t size)
+{
+	struct module_resources *res = &mod->priv.resources;
+	struct module_resource *container = container_get(mod);
+	const void *ptr;
+
+	MEM_API_CHECK_THREAD(res);
+	if (!container)
+		return NULL;
+
+	ptr = fast_get(dram_ptr, size);
+	if (!ptr) {
+		container_put(mod, container);
+		return NULL;
+	}
+
+	container->sram_ptr = ptr;
+	container->size = 0;
+	container->type = MOD_RES_FAST_GET;
+	list_item_prepend(&container->list, &res->res_list);
+
+	return ptr;
+}
+EXPORT_SYMBOL(mod_fast_get);
+#endif
+
+static int free_contents(struct processing_module *mod, struct module_resource *container)
+{
+	struct module_resources *res = &mod->priv.resources;
+
+	switch (container->type) {
+	case MOD_RES_HEAP:
+		rfree(container->ptr);
+		res->heap_usage -= container->size;
+		return 0;
+#if CONFIG_COMP_BLOB
+	case MOD_RES_BLOB_HANDLER:
+		comp_data_blob_handler_free(container->bhp);
+		return 0;
+#endif
+#if CONFIG_FAST_GET
+	case MOD_RES_FAST_GET:
+		fast_put(container->sram_ptr);
+		return 0;
+#endif
+	default:
+		comp_err(mod->dev, "Unknown resource type: %d", container->type);
+	}
+	return -EINVAL;
+}
+
 /**
  * Frees the memory block removes it from module's book keeping.
  * @param mod	Pointer to module this memory block was allocated for.
  * @param ptr	Pointer to the memory block.
  */
-int mod_free(struct processing_module *mod, void *ptr)
+int mod_free(struct processing_module *mod, const void *ptr)
 {
-	struct module_memory *mem;
-	struct list_item *mem_list;
-	struct list_item *_mem_list;
+	struct module_resources *res = &mod->priv.resources;
+	struct module_resource *container;
+	struct list_item *res_list;
 
+	MEM_API_CHECK_THREAD(res);
 	if (!ptr)
 		return 0;
 
 	/* Find which container keeps this memory */
-	list_for_item_safe(mem_list, _mem_list, &mod->priv.memory.mem_list) {
-		mem = container_of(mem_list, struct module_memory, mem_list);
-		if (mem->ptr == ptr) {
-			rfree(mem->ptr);
-			list_item_del(&mem->mem_list);
-			rfree(mem);
-			return 0;
+	list_for_item(res_list, &res->res_list) {
+		container = container_of(res_list, struct module_resource, list);
+		if (container->ptr == ptr) {
+			int ret = free_contents(mod, container);
+
+			list_item_del(&container->list);
+			container_put(mod, container);
+			return ret;
 		}
 	}
 
@@ -225,6 +375,22 @@ int mod_free(struct processing_module *mod, void *ptr)
 }
 EXPORT_SYMBOL(mod_free);
 
+#if CONFIG_COMP_BLOB
+void mod_data_blob_handler_free(struct processing_module *mod, struct comp_data_blob_handler *dbh)
+{
+	mod_free(mod, (void *)dbh);
+}
+EXPORT_SYMBOL(mod_data_blob_handler_free);
+#endif
+
+#if CONFIG_FAST_GET
+void mod_fast_put(struct processing_module *mod, const void *sram_ptr)
+{
+	mod_free(mod, sram_ptr);
+}
+EXPORT_SYMBOL(mod_fast_put);
+#endif
+
 int module_prepare(struct processing_module *mod,
 		   struct sof_source **sources, int num_of_sources,
 		   struct sof_sink **sinks, int num_of_sinks)
@@ -396,23 +562,33 @@ int module_reset(struct processing_module *mod)
 }
 
 /**
- * Frees all the memory allocated for this module
- * @param mod	Pointer to module this memory block was allocated for.
+ * Frees all the resources registered for this module
+ * @param mod	Pointer to module that should have its resource freed.
  *
  * This function is called automatically when the module is unloaded.
  */
 void mod_free_all(struct processing_module *mod)
 {
-	struct module_memory *mem;
-	struct list_item *mem_list;
-	struct list_item *_mem_list;
+	struct module_resources *res = &mod->priv.resources;
+	struct list_item *list;
+	struct list_item *_list;
 
+	MEM_API_CHECK_THREAD(res);
 	/* Find which container keeps this memory */
-	list_for_item_safe(mem_list, _mem_list, &mod->priv.memory.mem_list) {
-		mem = container_of(mem_list, struct module_memory, mem_list);
-		rfree(mem->ptr);
-		list_item_del(&mem->mem_list);
-		rfree(mem);
+	list_for_item_safe(list, _list, &res->res_list) {
+		struct module_resource *container =
+			container_of(list, struct module_resource, list);
+
+		free_contents(mod, container);
+		list_item_del(&container->list);
+	}
+
+	list_for_item_safe(list, _list, &res->cont_chunk_list) {
+		struct container_chunk *chunk =
+			container_of(list, struct container_chunk, chunk_list);
+
+		list_item_del(&chunk->chunk_list);
+		rfree(chunk);
 	}
 }
 EXPORT_SYMBOL(mod_free_all);
diff --git a/src/audio/module_adapter/module_adapter.c b/src/audio/module_adapter/module_adapter.c
index da0353d892ab..10f722fd9bbd 100644
--- a/src/audio/module_adapter/module_adapter.c
+++ b/src/audio/module_adapter/module_adapter.c
@@ -1289,18 +1289,14 @@ void module_adapter_free(struct comp_dev *dev)
 }
 EXPORT_SYMBOL(module_adapter_free);
 
-size_t module_adapter_heap_usage(struct processing_module *mod)
+size_t module_adapter_heap_usage(struct processing_module *mod, size_t *hwm)
 {
-	struct list_item *mem_list, *_mem_list;
-	size_t size = 0;
+	struct module_resources *res = &mod->priv.resources;
 
-	list_for_item_safe(mem_list, _mem_list, &mod->priv.memory.mem_list) {
-		struct module_memory *mem = container_of(mem_list, struct module_memory, mem_list);
+	if (hwm)
+		*hwm = res->heap_high_water_mark;
 
-		size += mem->size;
-	}
-
-	return size;
+	return res->heap_usage;
 }
 EXPORT_SYMBOL(module_adapter_heap_usage);
 
diff --git a/src/audio/src/src_common.c b/src/audio/src/src_common.c
index f96b3bc6e358..6331a6b9180e 100644
--- a/src/audio/src/src_common.c
+++ b/src/audio/src/src_common.c
@@ -627,12 +627,11 @@ int src_allocate_copy_stages(struct processing_module *mod, struct src_param *pr
 		return -EINVAL;
 	}
 
-	stage_dst[0].coefs = fast_get(stage_src1->coefs, coef_size[0]);
-	stage_dst[1].coefs = fast_get(stage_src2->coefs, coef_size[1]);
+	stage_dst[0].coefs = mod_fast_get(mod, stage_src1->coefs, coef_size[0]);
+	stage_dst[1].coefs = mod_fast_get(mod, stage_src2->coefs, coef_size[1]);
 
 	if (!stage_dst[0].coefs || !stage_dst[1].coefs)  {
 		comp_err(mod->dev, "failed to allocate coefficients");
-		fast_put(stage_dst[0].coefs);
 		return -ENOMEM;
 	}
 
@@ -708,12 +707,5 @@ __cold int src_free(struct processing_module *mod)
 
 	comp_info(mod->dev, "src_free()");
 
-#if CONFIG_FAST_GET
-	struct comp_data *cd = module_get_private_data(mod);
-	if (cd->param.stage1) {
-		fast_put(cd->param.stage1->coefs);
-		fast_put(cd->param.stage2->coefs);
-	}
-#endif
 	return 0;
 }
diff --git a/src/include/module/module/base.h b/src/include/module/module/base.h
index 2371d77124f5..881e74a2d108 100644
--- a/src/include/module/module/base.h
+++ b/src/include/module/module/base.h
@@ -59,7 +59,7 @@ struct module_data {
 	enum module_state state;
 	size_t new_cfg_size; /**< size of new module config data */
 	void *runtime_params;
-	struct module_memory memory; /**< memory allocated by module */
+	struct module_resources resources; /**< resources allocated by module */
 	struct module_processing_data mpd; /**< shared data comp <-> module */
 #endif /* SOF_MODULE_PRIVATE */
 };
diff --git a/src/include/sof/audio/mfcc/mfcc_comp.h b/src/include/sof/audio/mfcc/mfcc_comp.h
index bbc01030e157..ec5cc90eb40c 100644
--- a/src/include/sof/audio/mfcc/mfcc_comp.h
+++ b/src/include/sof/audio/mfcc/mfcc_comp.h
@@ -154,7 +154,7 @@ static inline int16_t *mfcc_buffer_wrap(struct mfcc_buffer *buffer, int16_t *ptr
 
 int mfcc_setup(struct processing_module *mod, int max_frames, int rate, int channels);
 
-void mfcc_free_buffers(struct mfcc_comp_data *cd);
+void mfcc_free_buffers(struct processing_module *mod);
 
 void mfcc_s16_default(struct processing_module *mod, struct input_stream_buffer *bsource,
 		      struct output_stream_buffer *bsink, int frames);
diff --git a/src/include/sof/audio/module_adapter/module/generic.h b/src/include/sof/audio/module_adapter/module/generic.h
index 1001c4ba450c..ced9fc710b11 100644
--- a/src/include/sof/audio/module_adapter/module/generic.h
+++ b/src/include/sof/audio/module_adapter/module/generic.h
@@ -19,6 +19,11 @@
 #include <sof/audio/source_api.h>
 #include "module_interface.h"
 
+/* The __ZEPHYR__ condition is to keep cmocka tests working */
+#if CONFIG_MODULE_MEMORY_API_DEBUG && defined(__ZEPHYR__)
+#include <zephyr/kernel/thread.h>
+#endif
+
 /*
  * helpers to determine processing type
  * Needed till all the modules use PROCESSING_MODE_SINK_SOURCE
@@ -116,13 +121,42 @@ struct module_param {
 };
 
 /**
- * \struct module_memory
- * \brief module memory block - used for every memory allocated by module
+ * \struct module_resources
+ * \brief module resources block - used for module allocation records
+ * The allocations are recorded so that they can be automatically freed
+ * when the module unloads.
  */
-struct module_memory {
-	void *ptr; /**< A pointr to particular memory block */
-	struct list_item mem_list; /**< list of memory allocated by module */
-	size_t size;
+struct module_resources {
+	struct list_item res_list;		/**< Allocad resource containers */
+	struct list_item free_cont_list;	/**< Unused memory containers */
+	struct list_item cont_chunk_list;	/**< Memory container chunks */
+	size_t heap_usage;
+	size_t heap_high_water_mark;
+#if CONFIG_MODULE_MEMORY_API_DEBUG && defined(__ZEPHYR__)
+	k_tid_t rsrc_mngr;
+#endif
+};
+
+enum mod_resource_type {
+	MOD_RES_UNINITIALIZED = 0,
+	MOD_RES_HEAP,
+	MOD_RES_BLOB_HANDLER,
+	MOD_RES_FAST_GET,
+};
+
+/**
+ * \struct module_resource
+ * \brief module memory container - used for every memory allocated by module
+ */
+struct module_resource {
+	union {
+		void *ptr; /**< Pointer to heap allocated memory */
+		struct comp_data_blob_handler *bhp; /**< Blob handler ptr */
+		const void *sram_ptr; /**< SRAM ptr from fast_get() */
+	};
+	struct list_item list; /**< list element */
+	size_t size; /**< Size of allocated heap memory, 0 if not from heap */
+	enum mod_resource_type type; /**< Resource type */
 };
 
 /**
@@ -157,7 +191,15 @@ int module_init(struct processing_module *mod);
 void *mod_alloc_align(struct processing_module *mod, uint32_t size, uint32_t alignment);
 void *mod_alloc(struct processing_module *mod, uint32_t size);
 void *mod_zalloc(struct processing_module *mod, uint32_t size);
-int mod_free(struct processing_module *mod, void *ptr);
+int mod_free(struct processing_module *mod, const void *ptr);
+#if CONFIG_COMP_BLOB
+struct comp_data_blob_handler *mod_data_blob_handler_new(struct processing_module *mod);
+void mod_data_blob_handler_free(struct processing_module *mod, struct comp_data_blob_handler *dbh);
+#endif
+#if CONFIG_FAST_GET
+const void *mod_fast_get(struct processing_module *mod, const void * const dram_ptr, size_t size);
+void mod_fast_put(struct processing_module *mod, const void *sram_ptr);
+#endif
 void mod_free_all(struct processing_module *mod);
 int module_prepare(struct processing_module *mod,
 		   struct sof_source **sources, int num_of_sources,
@@ -223,7 +265,7 @@ int module_adapter_trigger(struct comp_dev *dev, int cmd);
 void module_adapter_free(struct comp_dev *dev);
 int module_adapter_reset(struct comp_dev *dev);
 
-size_t module_adapter_heap_usage(struct processing_module *mod);
+size_t module_adapter_heap_usage(struct processing_module *mod, size_t *hwm);
 
 #if CONFIG_IPC_MAJOR_3
 static inline
diff --git a/src/include/sof/math/auditory.h b/src/include/sof/math/auditory.h
index eef073092e22..997c1a6c4a58 100644
--- a/src/include/sof/math/auditory.h
+++ b/src/include/sof/math/auditory.h
@@ -76,7 +76,8 @@ int16_t psy_mel_to_hz(int16_t mel);
  *			   filter coefficients.
  * \return                 Zero when success, otherwise error code.
  */
-int psy_get_mel_filterbank(struct psy_mel_filterbank *mel_fb);
+struct processing_module;
+int mod_psy_get_mel_filterbank(struct processing_module *mod, struct psy_mel_filterbank *mel_fb);
 
 /**
  * \brief Convert linear complex spectra from FFT into Mel band energies in desired
diff --git a/src/include/sof/math/dct.h b/src/include/sof/math/dct.h
index bb3aca81b202..21cdd8ba817f 100644
--- a/src/include/sof/math/dct.h
+++ b/src/include/sof/math/dct.h
@@ -29,6 +29,6 @@ struct dct_plan_16 {
 	bool ortho;
 };
 
-int dct_initialize_16(struct dct_plan_16 *dct);
+int mod_dct_initialize_16(struct processing_module *mod, struct dct_plan_16 *dct);
 
 #endif /* __SOF_MATH_DCT_H__ */
diff --git a/src/include/sof/math/fft.h b/src/include/sof/math/fft.h
index 504465401cad..16ae9ca97669 100644
--- a/src/include/sof/math/fft.h
+++ b/src/include/sof/math/fft.h
@@ -53,8 +53,12 @@ struct fft_plan {
 
 /* interfaces of the library */
 struct fft_plan *fft_plan_new(void *inb, void *outb, uint32_t size, int bits);
+struct processing_module;
+struct fft_plan *mod_fft_plan_new(struct processing_module *mod, void *inb,
+				  void *outb, uint32_t size, int bits);
 void fft_execute_16(struct fft_plan *plan, bool ifft);
 void fft_execute_32(struct fft_plan *plan, bool ifft);
 void fft_plan_free(struct fft_plan *plan16);
+void mod_fft_plan_free(struct processing_module *mod, struct fft_plan *plan16);
 
 #endif /* __SOF_FFT_H__ */
diff --git a/src/include/sof/math/matrix.h b/src/include/sof/math/matrix.h
index 74899371038a..f48f1ca4960d 100644
--- a/src/include/sof/math/matrix.h
+++ b/src/include/sof/math/matrix.h
@@ -10,6 +10,7 @@
 #ifndef __SOF_MATH_MATRIX_H__
 #define __SOF_MATH_MATRIX_H__
 
+#include <sof/audio/module_adapter/module/generic.h>
 #include <rtos/alloc.h>
 #include <ipc/topology.h>
 #include <stdint.h>
@@ -44,6 +45,20 @@ static inline struct mat_matrix_16b *mat_matrix_alloc_16b(int16_t rows, int16_t
 	return mat;
 }
 
+static inline struct mat_matrix_16b *mod_mat_matrix_alloc_16b(struct processing_module *mod,
+							      int16_t rows, int16_t columns,
+							      int16_t fractions)
+{
+	struct mat_matrix_16b *mat;
+	const int mat_size = sizeof(int16_t) * rows * columns + sizeof(struct mat_matrix_16b);
+
+	mat = mod_zalloc(mod, mat_size);
+	if (mat)
+		mat_init_16b(mat, rows, columns, fractions);
+
+	return mat;
+}
+
 static inline void mat_copy_from_linear_16b(struct mat_matrix_16b *mat, const int16_t *lin_data)
 {
 	size_t bytes = sizeof(int16_t) * mat->rows * mat->columns;
diff --git a/src/math/auditory/auditory.c b/src/math/auditory/auditory.c
index dbfe47b1699c..56cd6f99a24e 100644
--- a/src/math/auditory/auditory.c
+++ b/src/math/auditory/auditory.c
@@ -4,6 +4,7 @@
 //
 // Author: Seppo Ingalsuo <seppo.ingalsuo@linux.intel.com>
 
+#include <sof/audio/module_adapter/module/generic.h>
 #include <sof/audio/format.h>
 #include <rtos/alloc.h>
 #include <sof/math/auditory.h>
@@ -85,7 +86,7 @@ int16_t psy_mel_to_hz(int16_t mel)
 	return hz;
 }
 
-int psy_get_mel_filterbank(struct psy_mel_filterbank *fb)
+int mod_psy_get_mel_filterbank(struct processing_module *mod, struct psy_mel_filterbank *fb)
 {
 	int32_t up_slope;
 	int32_t down_slope;
@@ -200,8 +201,7 @@ int psy_get_mel_filterbank(struct psy_mel_filterbank *fb)
 	}
 
 	fb->data_length = &fb->scratch_data2[base_idx] - &fb->scratch_data2[0];
-	fb->data = rzalloc(SOF_MEM_FLAG_USER,
-			   sizeof(int16_t) * fb->data_length);
+	fb->data = mod_zalloc(mod, sizeof(int16_t) * fb->data_length);
 	if (!fb->data)
 		return -ENOMEM;
 
diff --git a/src/math/dct.c b/src/math/dct.c
index 15d23b67c7f9..192846e6a082 100644
--- a/src/math/dct.c
+++ b/src/math/dct.c
@@ -4,6 +4,7 @@
 //
 // Author: Seppo Ingalsuo <seppo.ingalsuo@linux.intel.com>
 
+#include <sof/audio/module_adapter/module/generic.h>
 #include <sof/audio/format.h>
 #include <sof/math/matrix.h>
 #include <sof/math/dct.h>
@@ -31,7 +32,7 @@
  * multiply with the returned matrix.
  * \param[in,out]  dct  In input provide DCT type and size, in output the DCT matrix
  */
-int dct_initialize_16(struct dct_plan_16 *dct)
+int mod_dct_initialize_16(struct processing_module *mod, struct dct_plan_16 *dct)
 {
 	int16_t dct_val;
 	int32_t arg;
@@ -51,7 +52,7 @@ int dct_initialize_16(struct dct_plan_16 *dct)
 	if (dct->num_in > DCT_MATRIX_SIZE_MAX || dct->num_out > DCT_MATRIX_SIZE_MAX)
 		return -EINVAL;
 
-	dct->matrix = mat_matrix_alloc_16b(dct->num_in, dct->num_out, 15);
+	dct->matrix = mod_mat_matrix_alloc_16b(mod, dct->num_in, dct->num_out, 15);
 	if (!dct->matrix)
 		return -ENOMEM;
 
diff --git a/src/math/fft/fft_common.c b/src/math/fft/fft_common.c
index a2afd09cf127..182bbb623078 100644
--- a/src/math/fft/fft_common.c
+++ b/src/math/fft/fft_common.c
@@ -5,6 +5,7 @@
 // Author: Amery Song <chao.song@intel.com>
 //	   Keyon Jie <yang.jie@linux.intel.com>
 
+#include <sof/audio/module_adapter/module/generic.h>
 #include <sof/audio/buffer.h>
 #include <sof/audio/format.h>
 #include <sof/common.h>
@@ -63,6 +64,55 @@ struct fft_plan *fft_plan_new(void *inb, void *outb, uint32_t size, int bits)
 	return plan;
 }
 
+struct fft_plan *mod_fft_plan_new(struct processing_module *mod, void *inb,
+				  void *outb, uint32_t size, int bits)
+{
+	struct fft_plan *plan;
+	int lim = 1;
+	int len = 0;
+	int i;
+
+	if (!inb || !outb)
+		return NULL;
+
+	plan = mod_zalloc(mod, sizeof(struct fft_plan));
+	if (!plan)
+		return NULL;
+
+	switch (bits) {
+	case 16:
+		plan->inb16 = inb;
+		plan->outb16 = outb;
+		break;
+	case 32:
+		plan->inb32 = inb;
+		plan->outb32 = outb;
+		break;
+	default:
+		return NULL;
+	}
+
+	/* calculate the exponent of 2 */
+	while (lim < size) {
+		lim <<= 1;
+		len++;
+	}
+
+	plan->size = lim;
+	plan->len = len;
+
+	plan->bit_reverse_idx = mod_zalloc(mod,	plan->size * sizeof(uint16_t));
+	if (!plan->bit_reverse_idx)
+		return NULL;
+
+	/* set up the bit reverse index */
+	for (i = 1; i < plan->size; ++i)
+		plan->bit_reverse_idx[i] = (plan->bit_reverse_idx[i >> 1] >> 1) |
+					   ((i & 1) << (len - 1));
+
+	return plan;
+}
+
 void fft_plan_free(struct fft_plan *plan)
 {
 	if (!plan)
@@ -71,3 +121,12 @@ void fft_plan_free(struct fft_plan *plan)
 	rfree(plan->bit_reverse_idx);
 	rfree(plan);
 }
+
+void mod_fft_plan_free(struct processing_module *mod, struct fft_plan *plan)
+{
+	if (!plan)
+		return;
+
+	mod_free(mod, plan->bit_reverse_idx);
+	mod_free(mod, plan);
+}
diff --git a/test/cmocka/src/audio/mixer/CMakeLists.txt b/test/cmocka/src/audio/mixer/CMakeLists.txt
index 723cb091ff61..ea8cad0bd79e 100644
--- a/test/cmocka/src/audio/mixer/CMakeLists.txt
+++ b/test/cmocka/src/audio/mixer/CMakeLists.txt
@@ -25,6 +25,7 @@ cmocka_test(mixer
 	${PROJECT_SOURCE_DIR}/src/audio/pipeline/pipeline-schedule.c
 	${PROJECT_SOURCE_DIR}/src/audio/pipeline/pipeline-stream.c
 	${PROJECT_SOURCE_DIR}/src/audio/pipeline/pipeline-xrun.c
+	${PROJECT_SOURCE_DIR}/src/audio/data_blob.c
 	${PROJECT_SOURCE_DIR}/src/module/audio/source_api.c
 	${PROJECT_SOURCE_DIR}/src/module/audio/sink_api.c
 	${PROJECT_SOURCE_DIR}/src/math/numbers.c
diff --git a/test/cmocka/src/common_mocks.c b/test/cmocka/src/common_mocks.c
index 3d844b803268..44b632997c7a 100644
--- a/test/cmocka/src/common_mocks.c
+++ b/test/cmocka/src/common_mocks.c
@@ -18,6 +18,7 @@
 #include <user/trace.h>
 #include <rtos/spinlock.h>
 #include <sof/audio/component_ext.h>
+#include <sof/audio/module_adapter/module/generic.h>
 #include <rtos/clk.h>
 #include <sof/lib/notifier.h>
 #include <rtos/wait.h>
@@ -72,6 +73,39 @@ void WEAK rfree(void *ptr)
 	free(ptr);
 }
 
+void WEAK *mod_alloc(struct processing_module *mod, uint32_t size)
+{
+	void *ret;
+	(void)mod;
+
+	ret = malloc(size);
+
+	assert(ret);
+
+	return ret;
+}
+
+void WEAK *mod_zalloc(struct processing_module *mod, uint32_t size)
+{
+	void *ret;
+	(void)mod;
+
+	ret = malloc(size);
+
+	assert(ret);
+
+	memset(ret, 0, size);
+
+	return ret;
+}
+
+int WEAK mod_free(struct processing_module *mod, const void *ptr)
+{
+	(void)mod;
+	free((void *)ptr);
+	return 0;
+}
+
 int WEAK memcpy_s(void *dest, size_t dest_size,
 		  const void *src, size_t count)
 {
diff --git a/test/cmocka/src/math/auditory/auditory.c b/test/cmocka/src/math/auditory/auditory.c
index 1e3e903fb5fb..65be2e0dcfce 100644
--- a/test/cmocka/src/math/auditory/auditory.c
+++ b/test/cmocka/src/math/auditory/auditory.c
@@ -14,6 +14,7 @@
 #include <string.h>
 #include <cmocka.h>
 #include <math.h>
+#include <sof/audio/module_adapter/module/generic.h>
 #include <sof/math/auditory.h>
 #include <sof/math/fft.h>
 #include "ref_hz_to_mel.h"
@@ -38,6 +39,8 @@
 
 #undef DEBUGFILES /* Change this to #define to get output data files for debugging */
 
+struct processing_module dummy;
+
 static void filterbank_16_test(const int16_t *fft_real, const int16_t *fft_imag,
 			       const int16_t *ref_mel_log,
 			       int num_fft_bins, int num_mel_bins, int norm_slaney,
@@ -87,7 +90,7 @@ static void filterbank_16_test(const int16_t *fft_real, const int16_t *fft_imag,
 	fb.scratch_data2 = (int16_t *)fft_out;
 	fb.scratch_length1 = fft_size / sizeof(int16_t);
 	fb.scratch_length2 = fft_size / sizeof(int16_t);
-	ret = psy_get_mel_filterbank(&fb);
+	ret = mod_psy_get_mel_filterbank(&dummy, &fb);
 	if (ret < 0) {
 		fprintf(stderr, "Failed Mel filterbank\n");
 		goto err_get_filterbank;
@@ -190,7 +193,7 @@ static void filterbank_32_test(const int32_t *fft_real, const int32_t *fft_imag,
 	fb.scratch_data2 = (int16_t *)fft_out;
 	fb.scratch_length1 = fft_size / sizeof(int16_t);
 	fb.scratch_length2 = fft_size / sizeof(int16_t);
-	ret = psy_get_mel_filterbank(&fb);
+	ret = mod_psy_get_mel_filterbank(&dummy, &fb);
 	if (ret < 0) {
 		fprintf(stderr, "Failed Mel filterbank\n");
 		goto err_get_filterbank;
diff --git a/test/cmocka/src/math/dct/dct.c b/test/cmocka/src/math/dct/dct.c
index 4cfe38ef803b..fd7b2f64d0b5 100644
--- a/test/cmocka/src/math/dct/dct.c
+++ b/test/cmocka/src/math/dct/dct.c
@@ -22,6 +22,8 @@
 #define MATRIX_MULT_16_MAX_ERROR_ABS  2.5
 #define MATRIX_MULT_16_MAX_ERROR_RMS  1.1
 
+struct processing_module dummy;
+
 static void dct_matrix_16_test(const int16_t *ref, int num_in, int num_out,
 			       enum dct_type type, bool ortho)
 {
@@ -41,7 +43,7 @@ static void dct_matrix_16_test(const int16_t *ref, int num_in, int num_out,
 	dct.num_out = num_out;
 	dct.type = type;
 	dct.ortho = ortho;
-	ret = dct_initialize_16(&dct);
+	ret = mod_dct_initialize_16(&dummy, &dct);
 	if (ret) {
 		fprintf(stderr, "Failed to initialize DCT.\n");
 		exit(EXIT_FAILURE);
diff --git a/test/cmocka/src/math/fft/fft.c b/test/cmocka/src/math/fft/fft.c
index 7c3279c96b57..92ac9380f0e7 100644
--- a/test/cmocka/src/math/fft/fft.c
+++ b/test/cmocka/src/math/fft/fft.c
@@ -13,6 +13,7 @@
 #include <cmocka.h>
 #include <stdbool.h>
 
+#include <sof/audio/module_adapter/module/generic.h>
 #include <sof/audio/buffer.h>
 #include <sof/audio/component.h>
 #include <sof/audio/format.h>
@@ -39,6 +40,8 @@
 #define MIN_SNR_512	125.0
 #define MIN_SNR_1024	119.0
 
+struct processing_module dummy;
+
 /**
  * \brief Doing Fast Fourier Transform (FFT) for mono real input buffers.
  * \param[in] src - pointer to input buffer.
@@ -68,7 +71,7 @@ static void fft_real(struct comp_buffer *src, struct comp_buffer *dst, uint32_t
 	if (!outb)
 		goto err_outb;
 
-	plan = fft_plan_new(inb, outb, size, 32);
+	plan = mod_fft_plan_new(&dummy, inb, outb, size, 32);
 	if (!plan)
 		goto err_plan;
 
@@ -85,7 +88,7 @@ static void fft_real(struct comp_buffer *src, struct comp_buffer *dst, uint32_t
 		*((int32_t *)dst->stream.addr + 2 * i + 1) = outb[i].imag;
 	}
 
-	fft_plan_free(plan);
+	mod_fft_plan_free(&dummy, plan);
 
 err_plan:
 	rfree(outb);
@@ -123,7 +126,7 @@ static void ifft_complex(struct comp_buffer *src, struct comp_buffer *dst, uint3
 	if (!outb)
 		goto err_outb;
 
-	plan = fft_plan_new(inb, outb, size, 32);
+	plan = mod_fft_plan_new(&dummy, inb, outb, size, 32);
 	if (!plan)
 		goto err_plan;
 
@@ -140,7 +143,7 @@ static void ifft_complex(struct comp_buffer *src, struct comp_buffer *dst, uint3
 		*((int32_t *)dst->stream.addr + 2 * i + 1) = outb[i].imag;
 	}
 
-	fft_plan_free(plan);
+	mod_fft_plan_free(&dummy, plan);
 
 err_plan:
 	rfree(outb);
@@ -181,7 +184,7 @@ static void fft_real_2(struct comp_buffer *src, struct comp_buffer *dst1,
 	if (!outb)
 		goto err_outb;
 
-	plan = fft_plan_new(inb, outb, size, 32);
+	plan = mod_fft_plan_new(&dummy, inb, outb, size, 32);
 	if (!plan)
 		goto err_plan;
 
@@ -210,7 +213,7 @@ static void fft_real_2(struct comp_buffer *src, struct comp_buffer *dst1,
 			(outb[size - i].real - outb[i].real) / 2;
 	}
 
-	fft_plan_free(plan);
+	mod_fft_plan_free(&dummy, plan);
 
 err_plan:
 	rfree(outb);
@@ -498,7 +501,7 @@ static void fft_real_16(struct comp_buffer *src, struct comp_buffer *dst, uint32
 	if (!outb)
 		goto err_outb;
 
-	plan = fft_plan_new(inb, outb, size, 16);
+	plan = mod_fft_plan_new(&dummy, inb, outb, size, 16);
 	if (!plan)
 		goto err_plan;
 
@@ -515,7 +518,7 @@ static void fft_real_16(struct comp_buffer *src, struct comp_buffer *dst, uint32
 		*((int16_t *)dst->stream.addr + 2 * i + 1) = outb[i].imag;
 	}
 
-	fft_plan_free(plan);
+	mod_fft_plan_free(&dummy, plan);
 
 err_plan:
 	rfree(outb);
@@ -553,7 +556,7 @@ static void ifft_complex_16(struct comp_buffer *src, struct comp_buffer *dst, ui
 	if (!outb)
 		goto err_outb;
 
-	plan = fft_plan_new(inb, outb, size, 16);
+	plan = mod_fft_plan_new(&dummy, inb, outb, size, 16);
 	if (!plan)
 		goto err_plan;
 
@@ -570,7 +573,7 @@ static void ifft_complex_16(struct comp_buffer *src, struct comp_buffer *dst, ui
 		*((int16_t *)dst->stream.addr + 2 * i + 1) = outb[i].imag;
 	}
 
-	fft_plan_free(plan);
+	mod_fft_plan_free(&dummy, plan);
 
 err_plan:
 	rfree(outb);
diff --git a/test/cmocka/src/math/matrix/matrix.c b/test/cmocka/src/math/matrix/matrix.c
index 66200bc3e632..8806344dce09 100644
--- a/test/cmocka/src/math/matrix/matrix.c
+++ b/test/cmocka/src/math/matrix/matrix.c
@@ -4,6 +4,7 @@
 //
 // Author: Seppo Ingalsuo <seppo.ingalsuo@linux.intel.com>
 
+#include <sof/audio/module_adapter/module/generic.h>
 #include <errno.h>
 #include <stdlib.h>
 #include <stdio.h>
@@ -23,6 +24,8 @@
 #define MATRIX_MULT_16_MAX_ERROR_ABS  1.5
 #define MATRIX_MULT_16_MAX_ERROR_RMS  0.5
 
+struct processing_module dummy;
+
 static void matrix_mult_16_test(const int16_t *a_ref, const int16_t *b_ref, const int16_t *c_ref,
 				int elementwise, int a_rows, int a_columns,
 				int b_rows, int b_columns, int c_rows, int c_columns,
@@ -38,17 +41,17 @@ static void matrix_mult_16_test(const int16_t *a_ref, const int16_t *b_ref, cons
 	int16_t x;
 	int i, j, k;
 
-	a_matrix = mat_matrix_alloc_16b(a_rows, a_columns, a_frac);
+	a_matrix = mod_mat_matrix_alloc_16b(&dummy, a_rows, a_columns, a_frac);
 	if (!a_matrix)
 		exit(EXIT_FAILURE);
 
-	b_matrix = mat_matrix_alloc_16b(b_rows, b_columns, b_frac);
+	b_matrix = mod_mat_matrix_alloc_16b(&dummy, b_rows, b_columns, b_frac);
 	if (!b_matrix) {
 		free(a_matrix);
 		exit(EXIT_FAILURE);
 	}
 
-	c_matrix = mat_matrix_alloc_16b(c_rows, c_columns, c_frac);
+	c_matrix = mod_mat_matrix_alloc_16b(&dummy, c_rows, c_columns, c_frac);
 	if (!c_matrix)  {
 		free(a_matrix);
 		free(b_matrix);
diff --git a/zephyr/sof_shell.c b/zephyr/sof_shell.c
index 60785c4eb5c4..f10a2c9275b5 100644
--- a/zephyr/sof_shell.c
+++ b/zephyr/sof_shell.c
@@ -55,13 +55,15 @@ static int cmd_sof_module_heap_usage(const struct shell *sh,
 	}
 
 	list_for_item_safe(clist, _clist, &ipc->comp_list) {
+		size_t usage, hwm;
+
 		icd = container_of(clist, struct ipc_comp_dev, list);
 		if (icd->type != COMP_TYPE_COMPONENT)
 			continue;
 
-		shell_print(sh, "comp id 0x%08x\t%8zu bytes\t(%zu max)", icd->id,
-			    module_adapter_heap_usage(comp_mod(icd->cd)),
-			    comp_mod(icd->cd)->priv.cfg.heap_bytes);
+		usage = module_adapter_heap_usage(comp_mod(icd->cd), &hwm);
+		shell_print(sh, "comp id 0x%08x%9zu usage%9zu hwm %9zu max\tbytes",
+			    icd->id, usage, hwm, comp_mod(icd->cd)->priv.cfg.heap_bytes);
 	}
 	return 0;
 }