Loading wasm module from sections vs byte buffer

[bdunlay]

I am curious about differences between loading a module from sections vs from a byte buffer.

wasm-micro-runtime/core/iwasm/include/wasm_export.h

Lines 302 to 339 in 3875c66

	/**
	* Load a WASM module from a specified byte buffer. The byte buffer can be
	* WASM binary data when interpreter or JIT is enabled, or AOT binary data
	* when AOT is enabled. If it is AOT binary data, it must be 4-byte aligned.
	*
	* Note: In case of AOT XIP modules, the runtime doesn't make modifications
	* to the buffer. (Except the "Known issues" mentioned in doc/xip.md.)
	* Otherwise, the runtime can make modifications to the buffer for its
	* internal purposes. Thus, in general, it isn't safe to create multiple
	* modules from a single buffer.
	*
	* @param buf the byte buffer which contains the WASM/AOT binary data,
	* note that the byte buffer must be writable since runtime may
	* change its content for footprint and performance purpose, and
	* it must be referencable until wasm_runtime_unload is called
	* @param size the size of the buffer
	* @param error_buf output of the exception info
	* @param error_buf_size the size of the exception string
	*
	* @return return WASM module loaded, NULL if failed
	*/
	WASM_RUNTIME_API_EXTERN wasm_module_t
	wasm_runtime_load(uint8_t *buf, uint32_t size,
	char *error_buf, uint32_t error_buf_size);
	/**
	* Load a WASM module from a specified WASM or AOT section list.
	*
	* @param section_list the section list which contains each section data
	* @param is_aot whether the section list is AOT section list
	* @param error_buf output of the exception info
	* @param error_buf_size the size of the exception string
	*
	* @return return WASM module loaded, NULL if failed
	*/
	WASM_RUNTIME_API_EXTERN wasm_module_t
	wasm_runtime_load_from_sections(wasm_section_list_t section_list, bool is_aot,
	char *error_buf, uint32_t error_buf_size);

The module install functions used within app mgr assume that the install request has an app payload that has been parsed into sections, as if it has been received from a remote host. The module install function calls wasm_runtime_load_from_sections. It then destroys "useless sections" which seems to be everything except the code section.

wasm-micro-runtime/core/app-mgr/app-manager/module_wasm_app.c

Lines 748 to 760 in 2bac6a4

	/* Load wasm module from sections */
	module = wasm_runtime_load_from_sections(bytecode_file->sections,
	false, err, err_size);
	if (!module) {
	snprintf(err_resp, sizeof(err_resp),
	"Install WASM app failed: %s", err);
	SEND_ERR_RESPONSE(msg->mid, err_resp);
	goto fail;
	}
	/* Destroy useless sections from list after load */
	destroy_part_wasm_sections(&bytecode_file->sections, sections1,
	sizeof(sections1) / sizeof(uint8));

If the module stored locally in flash storage (the module is not transmitted at install time), I don't technically need to parse the flash memory buffer into sections. I could just modify the wasm module install function to load the module directly from a byte buffer with wasm_runtime_load

Is there any measurable difference in terms of performance for loading wasm modules from byte buffers instead of from loading from sections? Am I wasting RAM by not loading into sections and allowing "useless sections" to be destroyed? I believe at least one difference is I will have to do memory management for the module buffer outside of the app manager.