Performance using load_pixels

[phitaylr]

py5 performance has been close enough to Processing's Java mode that I've never noticed any problems. However, while using load_pixels/update_pixels, py5's frame rate drops to between 1/3 and 1/4 of Processing. I got about same results compared to Processing's python mode, too. Is that something anyone else has noticed? Any suggestions for improving performance?

I know this is a silly example, but I was just playing around and am curious.

import py5

def setup():
    py5.size(800, 800)

def draw():
    c = py5.color(py5.random(255), py5.random(255), py5.random(255))
    py5.load_pixels()
    for i in range(py5.width*py5.height):
        py5.pixels[i] = c

    py5.update_pixels()
    
py5.run_sketch()

[hx2A]

py5 performance has been close enough to Processing's Java mode that I've never noticed any problems.

That makes me very happy to hear!

Any suggestions for improving performance?

To answer your question, first I'd have to explain a bit about how py5 works.

First, Python and Java don't share the same memory space, and second, there's a small performance penalty when a py5 method makes a call to java. Think of it as a toll you pay when going from Python to Java. The toll is small but it will accumulate if you do this in a loop, especially a loop for every pixel in the sketch.

This code here:

    for i in range(py5.width*py5.height):
        py5.pixels[i] = c

is going to be slow because py5.pixels[i] Python code to update a Java int array one pixel at a time.

The py5.load_pixels() and py5.update_pixels() calls should not the problem here. Note that py5.load_np_pixels() and py5.update_np_pixels() do the same work as py5.load_pixels() and py5.update_pixels(), plus an extra step.

And that extra step is using JPype's ability to create a numpy array that is backed by a Java Direct Buffer:

https://jpype.readthedocs.io/en/latest/userguide.html#buffer-backed-numpy-arrays

This means there is a performance improvement because Python can interact with the numpy array just as fast as any other numpy array because it is just a block of memory. It also means that py5.update_np_pixels() will be faster because it doesn't need to pass a large array to Java.

I haven't quite answered your question though. I don't have suggestions for how to improve performance of that code other than you should use np_pixels[] instead. That feature was added to py5 to provide users with an alternative to pixels[] that is much faster.

[phitaylr]

Thanks, your response was so helpful! Using np_pixels makes py5 noticeably faster, even compared Processing equivalent (no metrics, just an obviously faster framerate).

I'm exploring updating a high school intro to programming course from Processing (Java) with py5. I've traditionally used building image filters as opportunity to reinforce nested for loops. Perhaps this would be a better place to teach some numpy skills instead!

[hx2A]

I'm exploring updating a high school intro to programming course from Processing (Java) with py5. I've traditionally used building image filters as opportunity to reinforce nested for loops. Perhaps this would be a better place to teach some numpy skills instead!

Yes! py5 would be great for that. Numpy is the foundation of Python's data science and scientific computing tools. py5's numpy integration makes it an excellent way to teach those skills in the context of creative coding.

@villares is doing a lot of work with py5 and education, and he might have some suggestions to help you out.