ImageObject use results in "Context leak detected, msgtracer returned -1" with loops when run as script

[kontur]

Hello,

I have a Q&A script in which I am outputting stuff with Drawbot installed via pip.

Essentially, running the basic ImageObject sample code inside a loop, in a terminal script, results in multiple "Context leak detected, msgtracer returned -1" errors. This omits drawing images, but at times has even crashed my Mac.

The script: context-leak-debug-2.py

from drawBot import (
    image,
    fontSize,
    saveImage,
    fill,
    text,
    rect,
    size,
    ImageObject,
)


size(550, 300)

for i in range(100):
    print(i)
    # initiate a new image object
    im = ImageObject()

    # draw in the image
    # the 'with' statement will create a custom context
    # only drawing in the image object
    with im:
        # set a size for the image
        size(200, 200)
        # draw something
        fill(1, 0, 0)
        rect(0, 0, 400, 200)
        fill(1)
        fontSize(30)
        text("Hello World", (10, 10))

    # draw in the image in the main context
    image(im, (10, 50))
    # apply some filters
    im.gaussianBlur()

    # get the offset (with a blur this will be negative)
    x, y = im.offset()
    # draw in the image in the main context
    image(im, (300 + x, 50 + y))

saveImage("test.pdf")

When I run the same code without the imports in the Drawbot app I see the 1...99 traces, but never an error message (not sure if the error does not happen, or if the app hides the error message, from stderr I suppose — I think the latter). When running this in Terminal as python script I see the 1...99 traces, and eventually one or several "Context leak detected, msgtracer returned -1" — I suppose when the script hits the saveImage bit in the end, not during the loops themselves. It's somehow todo with the loop, so with range(10) I don't ever get the error, with range(1000) I see several such error message at the end. The longer the loop, the more errors, and dropped images in my actual use case.

I'm on an M1 MacBook 15.6.1 (24G90).

Attached the pip environment for my fresh install of pip install drawbot@git+https://github.com/typemytype/drawbot.git, Python 3.11.2.

requirements-debug.txt

My original use case is drawing a glyph (of two different font versions) into two ImageObjects, then comparing them, and adding some color filter, and drawing them to the pages just like in the example above.

[kontur]

The only DrawBot related mention of this error message I could find was this [forum thread](Context Leak detected, msgtracer returned -1) — The multipage save parameter doesn't seem to affect anything.

[justvanrossum]

It will probably help to wrap the leaky parts of the code with:

    with objc.autorelease_pool():
        ...leaky code...

Unfortunately, we don't know that DrawBot itself can improve this. But I've used the above pattern successfully to work around similar situations.

[kontur]

@justvanrossum thanks for the suggestion. I can't see objc.autorelease_pool make any difference. Or does that just prevent a worst "crash your computer"-case, while the errors still occur? Sorry, zero objc knowledge here:(

Also, I wonder what is the leaky part? This is a super minimal example simply using ImageObject.

I thought having the ImageObjects in the loop and writing them to a multipage pdf only after the loop would be the issue (keeping all those bitmaps in memory somewhere under the hood), but I get the same context leaks if I output PNGs in the loop, e.g.:

import os
import shutil
import objc
from drawBot import (
    image,
    fontSize,
    saveImage,
    fill,
    text,
    rect,
    size,
    ImageObject,
)

size(550, 300)

shutil.rmtree("test", ignore_errors=True)
os.mkdir("test")

for i in range(100):
    print(i)

    with objc.autorelease_pool():
        # initiate a new image object
        im = ImageObject()

        # draw in the image
        # the 'with' statement will create a custom context
        # only drawing in the image object
        with im:
            # set a size for the image
            size(200, 200)
            fill(1, 0, 0)
            rect(0, 0, 400, 200)
            fill(1)
            fontSize(30)
            text("Hello World", (10, 10))

        # draw in the image in the main context
        image(im, (10, 50))

        saveImage(f"test/{i}.png")

This does seem to draw all the images, though. So what exactly is the error about?

[justvanrossum]

I wish I understood :( The error is not something I've seen before, and indeed I cannot make it go away no matter how many autorelease pool thingies I add. So at this point, I am as stuck as you are.

[typemytype]

a similar issue #592

[typemytype]

there are several optimization possible in the this script (but I know what the goal):

• why using a ImageObject if you can draw directly into the pdf context, I would only recommend an ImageObject if you are planning to use any of the filters...
• wrap your loop with newDrawing() and endDrawing() see https://drawbot.com/content/canvas/pages.html#drawBot.newDrawing this prevents the internal stack from growing... what could lead to the leak as each image object has a reference in the internal drawBot stack

[kontur]

Thanks for additional info!

Unfortunately neither the newDrawing/endDrawing nor the objc.autorelease_pool() seem to avoid the crashes. The drawing calls above are just a minimal reproducible example based exactly of the ImageObject sample code, only adding loops around it.

My actual code uses the ImageObject along the lines of this, so I am drawing to the ImageObjects, saving bitmaps, comparing that pixel data, then applying filters to the ImageObjects to draw them into one page, and do this for an entire PDF of pages each with essentially just FormattedStrings:

size(w, h)
newDrawing()

for c in chars:
    with objc.autorelease_pool():
        old = ImageObject()
        old_pil = None
        with old:
            size(w, h)
            oldFont = installFont(oldFontPath)
            stroke(None)
            box = (padding * 2, padding, w / 2, h - padding * 2)
            txt = FormattedString(txt=txt, font=_font, fontSize=200, fill=color)
            textBox(txt, box)
            uninstallFont(oldFontPath)
            old_pil = saveImage("PIL")
        
        with new:
            ...

        calculate_pixel_difference_percentage(old_pil, new_pil)

        # Draw the actual PDF page, with coloring the old/new glyphs
        newPage(w, h)

        # Color and place the images
        old.colorMonochrome(color=oldColor, intensity=1)
        image(old, (0, 0))
        new.colorMonochrome(color=newColor, intensity=1)
        image(new, (0, 0))

endDrawing()
saveImage("output.pdf")

[typemytype]

an other idea: you are saving while the ImageObject context is still open: saveImage("PIL") is called inside the with statement.

# generate first all you pil data
oldPildata = list()
for c in chars:
    with objc.autorelease_pool():
        newDrawing()
        old = ImageObject()        
        with old:
            size(w, h)
            stroke(None)
            box = (padding * 2, padding, w / 2, h - padding * 2)
            txt = FormattedString(txt=txt, font=oldFontPath, fontSize=200, fill=color)
            textBox(txt, box)
        old_pil = saveImage("PIL")
        endDrawing()
        
        oldPildata.append((old, old_pil))

# same for your new image Object
# ...
        
# start the final pdf    
newDrawing()    
for i, c in enumerate(chars):
    
    old, oldPil = oldPildata[i]

    calculate_pixel_difference_percentage(old_pil, new_pil)

    # Draw the actual PDF page, with coloring the old/new glyphs
    newPage(w, h)

    # Color and place the images
    old.colorMonochrome(color=oldColor, intensity=1)
    image(old, (0, 0))
    new.colorMonochrome(color=newColor, intensity=1)
    image(new, (0, 0))
saveImage("output.pdf")
endDrawing()

bonus tip: you can provide the font path directly into a FormattedString. installFont activates the font, so it will be accessible during runtime of DB and the font is accessible with his postscriptname. Providing a font path provides CoreText the font data directly. So you can have multiple fonts with the same postscriptname in a single document.

[kontur]

Thanks for the additional tips. I cant' say any of those make a difference. I also watched the script run with Activity monitor open and as the loop runs, the "Context leak detected" error message pile up, I can see the memory footprint of the script grow until it crashes my machine somewhere around 30+GB.

It seems to me that fundamentally you cannot keep the ImageObject open in memory (list outside the loop or not) or this will crash (with enough iterations).

I've attempted to rewrite by saving the ImageObject stuff to an actual file on disk, but oddly enough, I can't get the colorMonochrome work, something along those lines:

oldColor = (1, 0, 0, 1)

newDrawing()

for i in range(1000):

    size(w, h)
    
    old = ImageObject()
    old_tmp = f"tmp/old-{i}.png"
    with old:
        size(w, h)
        ... draw stuff
        old.colorMonochrome(color=oldColor, intensity=1)
        saveImage(old_tmp) # < the saved image is grey?

    ...

endDrawing()
saveImage(output)

Interestingly, if I output the image outside the with clause like this:

    with old:
        size(w, h)
        ... draw stuff
        old.colorMonochrome(color=oldColor, intensity=1)
    image(old, (0, 0))
    saveImage(old_tmp)

... it has get the color, but I also get the context leaks, image is handled in memory outside the with clause — and this is, of course, how the sample code for ImageObject does demo it (also reading to the context leaks).

Trying this with objc.autorelease_pool doesn't work either:

oldColor = (1, 0, 0, 1)

newDrawing()

for i in range(1000):

    size(w, h)
    
    with objc.autorelease_pool():
        old = ImageObject()
        old_tmp = f"tmp/old-{i}.png"
        with old:
            size(w, h)
            ... draw stuff
            old.colorMonochrome(color=oldColor, intensity=1)

        image(old, (0, 0))
        saveImage(old_tmp)

What is noticeably with this though is that it is considerably slower, by a magnitude or two. Context leaks appear nonetheless.