Put the GPU at work for UF6

Hi Frederik,

When using UF6 (and the previous versions also) my computers CPU (Intel I5 with 4 cores) is working at 100 % while my GPU (NVIDIA GeForce GTX670) is doing ... right ... nothing at all.

There are softwares - I'm refering to "SETI@home" (*) - that are doing math calculations and are using not only the CPU's in your PC but also the GPU as you can see on the diagram below and the calculations of the GPU are much, much faster than the CPU's. One disadvantage = the heat production of the CPU/GPU combination.

Is there a possibility that this calculation method will be introduced in UF?

(*) SETI@home is a scientific experiment, based at UC Berkeley, that uses Internet-connected computers in the Search for Extraterrestrial Intelligence (SETI). You can participate by running a free program that downloads and analyzes radio telescope data.

The GPU seems an obvious fit for fractal calculations but unfortunately it doesn’t work at all. Almost all consumer-level GPUs perform their arithmetic using 32-bit floating point numbers which is really only enough for the first couple of zoom levels. You need 64-bit floats but only very expensive pro cards provide this. I’ve tested with simulating 64-bit math using multiple 32-bit operations but that turned out to be slower than the regular CPU.

Then there’s the problem that the GPU blocks all graphics work while it’s working on fractals so it essentially blocks the entire computer. Very hard to work around this. All in all, it just doesn’t work out. I know there are many examples of Mandelbrot GPU plotters but if you look closely, none of them provide proper zooming.

Thanks for the response Frederik

Sorry to resurrect an old thread, but many consumer cards now support 64 bit double precision floating point!

I have no idea about the overall statistics, but the UF fractals that I see on various parts of deviantart.com rarely have any significant magnification. The emphasis is on making artistic images, not on deep explorations.

I lost the link, but googling around also finds an arbitrary precision decimal math OpenCL library that out-performs CPU. Top-end AMD consumer cards do ~2TF fp64 right now which is more than you can get out of any CPU I'm aware of. The Instinct MI210 PCIe accelerators do 22TF fp64 and will probably end up on fire-sale on ebay later this year when the 300 series are released, but I don't think they have any Windows or Mac drivers.

The biggest problem would be that an LLVM frontend would need to be written to lower the UF language to GPU machine code or OpenCL to make user formulas work. This would provide other benefits ("free" access to AVX512 without writing additional code using the auto-vectorizers, support for any processor architecture) but although it's not something I think would be very complicated given the scope of the language I worked on that compiler system for ~5 years so I'm slightly out of touch with what "complicated" might mean there.

LLVM actually has a "My First Language Frontend" tutorial @ https://llvm.org/docs/tutorial/MyFirstLanguageFrontend/index.html if you feel like looking into how much work it might be, it might end up making an ARM port for the mac people easier as well.

There's still some things that don't make it straightforward. I managed to do a bit of fractal calculations on my GPU just last week and the speed is astonishing as long as you stay in single precision territory, however:

1. The code is entirely different from regular CPU rendering, in an established software, switching from one to the other isn't easy. It could, for example, be the case that fractal formulas and coloring algorithms are handled by objects that flat out can not exist in GPU render code, so it would require quite a bit of work to translate those.
2. Double precision is unlocked on AMD cards, Nvidia "consumer" cards (that includes everything up to the 40-fucking-90 Ti!) will do double, but nerf the performance for no other reason than Nvidia wanting more money. The chips can do it, the just won't.
3. It is extremely easy to exceed even double precision when zooming for just a few seconds.
4. Even non-zoomed images can require high precision, for instance when working with very high bailouts to make stuff like exponential smoothing look nice

All that being said, that still leaves a substantial subsets of all fractals in UF that would greatly benefit from GPU support. I know there are other programs that will happily chug along on a GPU without blocking the use of the PC, like Chaotica or Fractron 9000. You have leave them rendering in the background just fine and work on something else, as long as you don't want to play a demanding game at the same time.

Personally, I would love to see it, but I kind of fear that by now UF has lost so much popularity that implementing such a labor-intensive feature might just not be worth it. On the other hand, having the UI of UF and GPU support could revive it a bit. Who knows, there's a saying in German: the last thing to die is hope.

I am actually curious about whether it could be possible to translate UF formulas into shaders, at least the simpler ones. I have done it with my burning Mandala, the standard MB and Julia sets as well as the Burning ship with no problem, including anti-aliasing. But the program just draws them, it has zero functionality other than that. My 3900X takes about a minute to draw a julia set at 1000x1000 with good anti-aliasing (128 samples per pixel), my GTX 1070 runs the same fractal it at 15 FPS.

I think it should be possible to translate user formulas into shaders. I experimented with this quite a few years ago so it sounds like the technology has advanced and it's worthwhile to try it again.

I am actually curious about whether it could be possible to translate UF formulas into shaders, at least the simpler ones. I have done it with my burning Mandala, the standard MB and Julia sets as well as the Burning ship with no problem, including anti-aliasing. But the program just draws them, it has zero functionality other than that. My 3900X takes about a minute to draw a julia set at 1000x1000 with good anti-aliasing (128 samples per pixel), my GTX 1070 runs the same fractal it at 15 FPS.

A long time ago (I think I had a Radeon HD6970 at the time) I discovered that the Milkdrop plugin for Winamp optionally used HLSL shaders for visualizations. I decided to write a Julia set that animated itself to the music. The biggest issues there turned out to be that

• Milkdrop either wasn't being developed or the developer had said he wasn't porting it past DirectX 9. This was back when there were still people running Windows 95 for their games because they thought the NT kernel based Windows versions were too slow, or more likely read it somewhere online without trying it.
• DX9 only supported ps / vs 2_x.
• for loops were considered a static construct in HLSL, because it unrolled them fully.
• Most of the fractal code needed to be done in the vertex shader which only supported a total of 256 instructions including the unrolled loop for fractal iteration.

Luckily there's a lot more tolerance for missing detail in an animation than a still image and I was able to get something that looked good fit into that instruction limit. Naturally about a year later the hard drive Winamp and the plugin presets were on crashed and couldn't be recovered, but I was getting something like 140fps at 1080p. Julia doesn't need huge iteration counts to look good while it's fairly zoomed out which helped a lot. Current HLSL doesn't have an instruction count limit, only a register / variable limit.

I've been hoping someone would write a visualizer for some program that could be customized like Milkdrop but used DX12 for years but it doesn't seem to be happening, or at least I can't find it. The iteration count would need to go up quite a bit to look good on a 4k display but that old card only managed 2.3 TFLOPS fp32 and I'm up to something like 70 or above now and have 140 TFLOP fp16 as an option for earlier iterations if it needed to be optimized.