In this work we explore large-scale parallel rendering on HPC systems. The major deployment platform for this work is the scalable rendering library IceT, which is made freely available. Our main approach is a technique known as sort-last parallel rendering, but along the way we introduce several simple to implement but powerful modifications that greatly improve the efficiency including minimal copy image interlacing for better load balancing and telescoping compositing for arbitrary job sizes. Visit the IceT project page for access to the software, documentation, and further papers and information on scalable rendering. For users more interested in easy to read and edit code than high efficiency, we also provide the miniGraphics miniapp.
"Comparing Binary-Swap Algorithms for Odd Factors of Processes." Kenneth Moreland. In Proceedings of the 8th IEEE Symposium on Large Data Analysis and Visualization (LDAV). October 2018. DOI 10.1109/LDAV.2018.8739210.
A key component of most large-scale rendering systems is a parallel image compositing algorithm, and the most commonly used compositing algorithms are binary swap and its variants. Although shown to be very efficient, one of the classic limitations of binary swap is that it only works on a number of processes that is a perfect power of 2. Multiple variations of binary swap have been independently introduced to overcome this limitation and handle process counts that have factors that are not 2. To date, few of these approaches have been directly compared against each other, making it unclear which approach is best. This paper presents a fresh implementation of each of these methods using a common software framework to make them directly comparable. These methods to run binary swap with odd factors are directly compared. The results show that some simple compositing approaches work as well or better than more complex algorithms that are more difficult to implement.
Here are the slides used to present this material. The slides really need a narrator to explain the algorithms, but they have nice animations that help describe the content.
The software used for testing in this paper is being made available in the miniGraphics miniapp, which is released as open-source software and is made available through a GitHub repository. The experiments were specifically performed with the repository at SHA 50630f9 with the exception of the 234-composite algorithm (which was implemented afterward). These use the code at SHA 4e647c2. If you really want to replicate the exact same code for reproducibility, you can download this exact version. For most purposes, though, you are probably better off with the latest version of miniGraphics.
For those interested in exploring the data collected by the reported experiments more thoroughly, I also post all the log files collected through the experiments here. The miniGraphics application writes out its timing measurements in yaml format. Because these timing logs can get verbose, each are compressed with gzip.
The figures in the paper are created in Python using pandas and toyplot modules. I also execute the Python script in Jupyter notebooks. These notebooks are provided for you to either directly run, copy into your own scripts, or use as inspiration for whatever processing you prefer.
"An Image Compositing Solution at Scale." Kenneth Moreland, Wesley Kendall, Tom Peterka, and Jian Huang. In Proceedings of 2011 International Conference for High Performance Computing, Networking, Storage and Analysis (SC '11). November 2011. DOI 10.1145/2063384.2063417.
The only proven method for performing distributed-memory parallel rendering at large scales, tens of thousands of nodes, is a class of algorithms called sort last. The fundamental operation of sort-last parallel rendering is an image composite, which combines a collection of images generated independently on each node into a single blended image. Over the years numerous image compositing algorithms have been proposed as well as several enhancements and rendering modes to these core algorithms. However, the testing of these image compositing algorithms has been with an arbitrary set of enhancements, if any are applied at all. In this paper we take a leading production-quality image compositing framework, IceT, and use it as a testing framework for the leading image compositing algorithms of today. As we scale IceT to ever increasing job sizes, we consider the image compositing systems holistically, incorporate numerous optimizations, and discover several improvements to the process never considered before. We conclude by demonstrating our solution on 64K cores of the Intrepid BlueGene/P at Argonne National Laboratories.
You can download the artifacts generated for this paper. This is a collection of the raw timing data collected during the scaling studies.
"Sort-Last Parallel Rendering for Viewing Extremely Large Data Sets on Tile Displays." Kenneth Moreland, Brian Wylie, and Constantine Pavlakos. In Proceedings of IEEE 2001 Symposium on Parallel and Large-Data Visualization and Graphics, October 2001, pp. 85–92.
Due to the impressive price-performance of today’s PC- based graphics accelerator cards, Sandia National Laboratories is attempting to use PC clusters to render extremely large data sets in interactive applications. This paper describes a sort-last parallel rendering system running on a PC cluster that is capable of rendering enormous amounts of geometry onto high-resolution tile displays by taking advantage of the spatial coherency that is inherent in our data. Furthermore, it is capable of scaling to larger sized input data or higher resolution displays by increasing the size of the cluster. Our prototype is now capable of rendering 120 million triangles per second on a 12 mega-pixel display.