When does a finished async task release its RAM?

[victorallume]

I have an async task that I need to run repeatedly, but only one instance of it will ever be running at one time. I want to make sure that when the task is finished (either because it finished by itself, or was cancelled), it deallocates any RAM it was using, so that I don't end up running out of RAM.

My code is roughly:

# this is called repeatedly
if tsk is None:
    tsk = asyncio.create_task(my_task())
else:
    if tsk.done(): 
        result = await tsk
        ...
        tsk = asyncio.create_task(my_task())
...
# elsewhere (above code can be run again after this section has run)
tsk.cancel()
await tsk

Does awaiting the task object after it's done/cancelled release any RAM the task was using?

[xyzzy42]

Give this a test:

import asyncio
import time

async def task(x):
    print(f"Task {x} running")
    data = bytes(100000)
    await asyncio.sleep(1)
    print(f"Task {x} done")
    return x

async def main():
    t = None
    while True:
        await asyncio.sleep_ms(500)
        if t is None:
            t = asyncio.create_task(task(time.time()))
            print("Created task")
        if t.done():
            result = await t
            print(f"Task {result} joined")
            t = None
        gc.collect()
        print("Free memory", gc.mem_free())

asyncio.run(main())

[peterhinch]

A task is like any other Python object. If the garbage collector determines there are no references to the object, its RAM will be recovered on the next collect. Your tsk variable will point to the new task, leaving the old (completed) task with no references pointing to it.

Your code should be safe.

[peterhinch]

An alternative way of coding this, perhaps more in tune with the Zen of realtime programming, is to use a queue to link the producer and consumer. Something like:

from primitives import RingbufQueue  # Microcontroller-optimised version of asyncio.Queue

q = RingbufQueue(10)
tsk = None  # Global reference for cancellation
async def producer():
    global tsk
    while True:
        tsk = asyncio.create_task(my_task)
        res = await tsk
        if res is not None:  # Task was not cancelled
            await q.put(res)

async def consumer():
    asyncio.create_task(producer())
    async for result in q:
        # process result

Assumes that my_task returns None on cancellation.