memory problems

[jet689]

I am sorry for my poor code quality. I made something that writes frames from files to a display and I seriously can't figure out why it is getting a memory error. each frame file is the correct size to fit within its memory yet the memory usage just goes up and up until it stops working. here is the error
Traceback (most recent call last): File "<stdin>", line 30, in <module> MemoryError: memory allocation failed, allocating 396 bytes
here is the code:

import machine
import ssd1306
from time import sleep
import math
import random
import gc
gc.enable()
# from single_frame import frames
# Initialize the I2C communication
i2c = machine.SoftI2C(scl=machine.Pin(5), sda=machine.Pin(4))
# Reset the OLED display (optional)
pin = machine.Pin(16, machine.Pin.OUT)
pin.value(0)  # Set GPIO16 low to reset OLED
pin.value(1)  # While OLED is running, set GPIO16 high
# Create an instance of the SSD1306 OLED driver
oled_width = 128
oled_height = 64
oled = ssd1306.SSD1306_I2C(oled_width, oled_height, i2c)
oled.contrast(255)
frame_count=19
frames="idk"
im="idk"
for i in range(0,frame_count):
    print(gc.mem_free(),"pre")
#     del frames
#     del im
#     print(gc.mem_free(),"del")
    gc.collect()
    
    im=__import__(f"/exports/output_frames{i}")
    frames=im.frames[0]
    print(gc.mem_free(),"post")
#     print(frames)
    print(i)
    oled.fill(0)
    xadd=(oled_width-len(frames[0]))/2
#     print(xadd)
    print(gc.mem_free(),'col')
    for y,valx in enumerate(frames):
    #     print(valx)
        for x,val in enumerate(valx):
#             print(val)
            if val>=110:
                oled.pixel(x+int(xadd),y,1)
    oled.show()
    sleep(0.1)```

[kjm1102]

By my count your line 30 memory occurs at im=import(f"/exports/output_frames{i}"). The only way I've been able to get around running out of memory is to declare a byte array early in the program to reserve space before memory gets fragmented then put stuff into that rather than a variable. It's a PITA because byte array lacks some of the functionality of variables but I've tried setting up a variable early to reserve space then writing over it later but it never plays well with gc for some reason.

[peterhinch]

Importing a .py invokes the compiler: it's possible that this is causing problems, given that import is performing repeatedly. The compiler uses a significant RAM usage,One option might be to try using compiler creating .mpy files, which means that the program loads MicroPython bytecode.

As @kjm1102 suggests, even more RAM-efficient is initialising a bytearray, populating it from each binary file.

[shariltumin]

You may want to try deleting the reference in sys.modules of im before you do del. You can try this after sleep(0.1)

    ...
    sleep(0.1)
    sys.modules.pop(f"/exports/output_frames{i}")
    del frames,im; gc.collect()

but memory fragmentation will still occur.

[peterhinch]

To put this into context the SSD1306 frame buffer is 1KiB in size. This is tiny. I have been developing micropython-touch on the Pico, one of the displays having a framebuf of 78,600 bytes. I have had no OOM problems. The more I think about this, the more convinced I am that the problem is the repeated invocation of the compiler.

The approach I use is to create the frame buffer first, then perform all the imports, then start running code. That way the (huge) frame buffer is created before any RAM fragmentation can occur. Then the compiler gets all the remaining RAM to work in. Finally the code gets a look-in.

[shariltumin]

Thanks for the micropython-touch. Looks impressive, I'm sure I'll need it soon enough.