GitLab

When you render a dense image, the load balancing should be pretty
even. At any rate, it probably won't help to shift around pixels when
there are the same amount of pixels everywhere, so ultimately this
is a waste of time.

IceT insists on using sparse images most of the time because they are
almost always better (at least at the beginning part of the
compositing). Add an option to SimpleTiming to draw images that have no
background pixels so that the "sparse" images are equivalent to dense
images. This is done by making the depth of background pixels slightly
above and the opacity never 0.

The camera angles in SimpleTiming are more-or-less perfect for IceT's
image compositing. It is a fairly common case to want to zoom into the
data, especially if there is some intersting detail. This could add
extra work and load imbalance and could make the tests more interesting.

Hopefully this can be used to test odd process group sizes. Randomly
picked group sizes should commonly have large factors.

This is added for comparison purposes only. The telescoping binary swap
(just named binary swap) is generally faster (but maybe not always).

There is now a radix-kr algorithm that should handle odd factors better
than telescoping (plus supports non-power-of-2 factors).

There was an issue with how radix-kr was iterating over images to send
where it was trying to send images that did not exist.

When dealing with a factor that does not divide evenly, there was an
error that made the process in the remainder think it still had an
image.

I had meant to add it earlier, but I did it wrong.

The radix-kr is essentially the radix-k algorithm with some ideas from
2-3 swap added in. Rather than forcing all the k's in radix-k to be
factors, radix-kr allows the k to have a remainder when splitting the
process. The remaining processes participate in that round by splitting
their image and sending them off, but they receive nothing that round
and then go idle. Although this adds some imbalance, it does not add
much. It also makes keeping track of partitions easier than 2-3 swap.

Previously, if a state buffer was needed and the existing one did not
match the size and type exactly, the old buffer was freed and a new
buffer was malloced. However, malloc can be slow and it is possible to
reuse a buffer if the new one being asked for is smaller than the old
one. Thus, change the semantics to use a previously allocated buffer if
it is at least as big as needed. This might leave pools of data larger
than what we need, but will reduce the overall number of malloc calls
needed.

I'm sure this is from a mistaken keypress while navigating the file a
while ago.

Instead of detecting the platform and guessing the right file delete
function, use the cmake -E command to do the delete in a cross-platform
way.

Previously, if OpenGL was enabled all tests would create a render window
even if it was never used because they were all crammed into the same
executable that initalized with the OpenGL context. This is an artifact
from early versions of IceT that always required OpenGL.

Creating an OpenGL context shouldn't change the results of the test, but
it was annoying to have a bunch of windows created for every test. This
change separates out the OpenGl tests from those that don't use it so
that most of the tests now just run in the background.

Some of the files in the tests directory used a dash to separate words
(e.g. test-config.h and test-util.h) whereas others used an underscore
(e.g. test_codes.h and mpi_comm.h). Renamed the files such that they all
use underscores, which matches better the filenames used elsewhere.

The subset command of the communicator takes an array of ranks, but that
array should not be changed. Declare that array const in all versions of
the function. (This requires a const cast when calling the MPI version
since that function does not take a const array even though it should.)

At the end of each test each process reported whether it got an IceT or
OpenGL error including if it is no error. That can be helpful in part to
know that the process successfully completed, but for tests on very
large processes it generated excessively large log files. Instead
suppress the report if there is no error.

The usage of the -max-image-split-study of SimpleTiming states that it
tries doubling the max split. For some reason I implemented it by
multipling by the magic k value each time. Change it so it actually just
doubles the max image split and does a more complete search.

Previously, the root process would print the log at the end of
SimpleTimingDoRender. The problem is that in the scaling studies the
world communicator is partitioned so that there are multiple root
processes running at once. I've been having trouble with log entries
stomping over each other.

This change holds all the timings in a buffer rather than print them.
After scaling studies are complete, all log entries are collected to the
world root and printed out there.

Turns out the way I was recursively dividing partitions I was getting
multiple partitions that were the same size. This change cuts out the
repeated partition sizes letting processes go idle during the testing.

The 2-3 factor scaling routine in SimpleTiming was not properly checking
that the group size was large enough to handle the number of tiles used.
This didn't cause any real problems but caused the test to report failure
even though nothing really went wrong. Fixed that problem.