END OF AN ERA, FRACTALFORUMS.COM IS CONTINUED ON FRACTALFORUMS.ORG

I think the main difficulty with arbitrary precision mathematics on the GPU is to organize streams (large datasets) and functions in such a way that you can pass these large values between them. FOr instance on ATI a function that doesn't write its output to a stream can at most return a 128 bits value. So you might have to use a C style preprocessor that inlines such functions call. For mandelbrot and mandelbulb the usual iterative approach will involv numbers that are small (ex < 2.0) so fixed point will be the most appropriate to use. DE will be much harder where you have to do logarithms. I can imagine that code will have to be rewritten so that you don't have a GPU function that marches a single ray, but instead calculates the the size of the next step for a single ray, and the call those repeatedly.

128 bits precision would be the "easiest" to do, more than that and your numbers will have to be placed in streams, and worked on in memory rather than in registers. Cached memory access is very fast, but since streams are generally the objects passed in CPU->GPU calls, and registers are used in GPU functions, more of program logic will have to be done by the CPU, and the GPU will just do the dumb crunching of the numbers.

Double precision can be emulated by combining two single precision floats, as detailed in this
CUDA forum posting.

http://forums.nvidia.com/index.php?showtopic=73067

You lose about factor 10-20 in speed, so much of the GPU's speed advantage is lost.

ATI cards should do better with integers than nVidia cards, because these can only multiply
two 24 bit precision numbers in 4 clock cycles (they are re-using the integer parts of the
floating point ALU, which only requires 24 bits of mantissa to work with). So working with
32 bit ints is slower on nVidia than working with floats.

Christian