Unloading modules to save RAM

[brianreinhold]

Is it possible to unload a module that has been imported? In particular I have the following import statement

from picocore.bt.btsig_thermometer import BtSigThermometer

btsig_thermometer is a module I wrote

I import the module after I have connected to a BT SIG health device and want to handle the thermometer service. The code looks like this

      #======================= BT_SIG THERMOMETER
      thermometer_service: PhdService | None = find_service(UUID(_HealthThermometer), phd_info.phdServices)
      if thermometer_service is not None:
          logger.info('LNI: Got Health Thermometer Service') # type: ignore
          mds.coincident_time = await self.handle_date_time(thermometer_service, self.coincidentTime)
          from picocore.bt.btsig_thermometer import BtSigThermometer
          task_health_thermometer = asyncio.create_task(BtSigThermometer(self.le_secure).
                              btsig_thermometer(thermometer_service, self.deviceConnection, mds))
          return

When the device disconnects, I would like to unload the module. I tried
del picocore.bt.btsig_thermometer
as done in some other archived threads but I get a picocore not defined error. Is it possible to remove an imported module in today's Micropython? If so, how would I do that?

[ned-pcs]

You can do something like del sys.modules['modname'] but then you may need to track down other references in other modules. Like in your example you would probably have to do something like BtSigThermometer = None.

[jimmo]

Yep exactly this (both using sys.modules but also the complexity of finding all the ways that the reference can be held).

@brianreinhold really the best solution is to freeze (or soon, RomFS, see #8381 Damien has been working on this again recently) the code so that it doesn't take any memory.

[brianreinhold]

@jimmo Freezing is probably the only way to go. We are coding a remote patient monitoring gateway that communicates with health devices and sends that data to a health care provider. The gateway is meant to run continuously; all the patient does is take measurements with the device. During communications we need to instantiate one of several transcoders depending upon the device type. These transcoders live as long as the device communicates with the gateway. The unfortunate thing is no one follows standards and the BTLE standards that exist are not well designed in the sense there is a different transcoder for each device type (it doesn't have to be that way). On top of that most manufactures go for proprietary options anyways.

So in operations there will be never ending loading and unloading of these transcoders as the weeks wear on, and fragmentation is likely inevitable regardless of the efforts we put in to minimize it.

[Josverl]

I have tried hard to unload modules, and found that while unloading and deleting all my references, still some memory remains unavailable even after attempted cleanup. Most likely due to a combination of initialized singletons and memory fragmentation. Cutting out the code that tried to clean up, saved more than running the code did in most cases.

So invest in a build workflow that freezes the stable modules, and you can set the python path to still allow to load modules from the filesystem to keep the inner dev loop simple and fast.