I have been a POV-Ray fan for a long time. I know there have been several
approaches to distributed rendering over the years, but after retiring I was
looking for a project and decided to create my own distributed client-server
rendering system, using POV-Ray 3.7.0.10 as the base.

So far the results have been encouraging. With 8 clients, measured speedup for
still-image rendering ranges from 88.4% to 98.2% scaling efficiency, depending
on image size and complexity (larger, more complex images scale best). Animation

depending on scene characteristics. These gains come not only from distributing
work across clients, but also from parser and caching optimizations that
eliminate a significant amount of repeated work.

Here is a summary of the project.

For hardware, I wanted to see what could be accomplished with a cluster of
Raspberry Pi 5 Compute Modules. To that end I built two self-contained four-node
Pi clusters. I'm happy to share hardware details if anyone is interested, but
the hardware is not really the focus of this post.

The more interesting work was creating the client-server software environment.
Starting with POV-Ray 3.7.0.10, I modified the renderer to operate as a
non-terminating client and optimized it for distributed operation. The server
assigns work and collects results. Work distribution itself is straightforward:
still images are divided into row ranges, while animations are distributed one
frame per client.

The key client-side modifications are aimed at avoiding unnecessary repeated
work. Each client maintains a single persistent POV-Ray session across multiple
tasks and renders. Parsed scene information is cached so that repeated renders
of the same scene do not require reparsing. In addition, I modified the parser
to support a static keyword, allowing large clock-independent structures to be
cached and reused between animation frames. Similar concepts have been explored
before, but the persistent-session architecture makes this particularly
effective.

I also added a feature that I personally felt was missing from POV-Ray: the
ability to call precompiled native functions directly from the Scene Description
Language. To support this, I developed a plugin system and extended the parser
with five new function types: userfun(), uservectfun(), usercolorfun(),
useruv(), and userfracfun(), returning scalar, vector, color, UV, and 4D values
respectively.
For example:
uservectfun("curl_field", x, y, z)
where curl_field is a function exported by a dynamically loaded plugin.

The server side includes a number of supporting capabilities, including
heartbeat monitoring, failed-task reassignment, thermal management, archive
reuse, and delta synchronization of include files.

I'd be interested in hearing whether others have experimented with similar
persistent-session approaches, parser extensions, or SDL plugin mechanisms.

Post a reply to this message