Generating Fractals with SSE/SSE2

Dominique wrote:

Peter,
 
I just downloaded your fractal program from
 
http://www.codeproject.com/cpp/fractalssse.asp
 
I have managed to import it as a project to my Microsoft Visual C++ .NET version 7.0.9955 and compiled and linked it and it runs really fine.
 
I am studying the iteration of transendental functions in my PhD, so I look at iterating, for example, functions like f(z) = c exp(z) where c is the parameter.
 
I’d like to customize your code so it calculates julia sets for such functions, and I want to ask for your permission.
I have only a basic level of skill in C++ coding and no skill in assembler, but it looks like I might just need to alter the PaintJuliaFPU method in factals.cpp.
I had the intention of adding
 
#include <math.h>
 
to the tech.h file and using the exp function from math.h but I notice you have commented out the
 
#include <math.h>
 
line in tech.h. Can you remember if there was any particular reason for this?
 
Are you, in principle, prepared to let me make some modifications to my copy of your code?
 
I hope this email gets to you.
 
Dominique
 

 

Peter wrote:

Dominique,
 
Are you, in principle, prepared to let me make some modifications to my copy of your code?
Certainly, you can make any modifications. If you will distribute the modified version, credits would be appreciated (just mention me somewhere in your readme file or help file).
 
But it may be easier for you to start from small and simple code base. The program from my article is bloated with trivial details such as switching between SSE and FPU modes or creating DirectDraw surfaces. If you don’t need SSE or DirectDraw, you may found this small program useful. It has poor performance, but is easier to understand and modify.
 
#include line in tech.h. Can you remember if there was any particular reason for this?
The standard functions from math.h require startup code, which increases size of the executable by 27 Kb. I replaced these functions with their home-made analogs [atod(), ceil(), dtoi(), and so on] to keep the file size small. If you wish to exclude the startup code too, use intrinsic transcendental functions described in the article by Dierk “Chaos” Ohlerich. I included them in the small program mentioned above.

double ZxSave = 0.0;
double ZySave = 0.0;
int K = 1;
int L = 1;
 
bool PeriodicityTest(double Zx, double Zy)
{
	// If period detected
    if(Zx == ZxSave && Zy == ZySave)
    {
		return true;
    }
    else
    {
		K--;
        // Update ZSave for comparison
        // K & L operate to increase the number of iterations between updates of ZSave
        // Update becomes less frequent as the number of iterations increase,
		// because at higher iterations periods become longer.
        if(K == 0)
        {
			ZxSave = Zx;
			ZySave = Zy;
            L *= 2;
            K = L;
        }
 
		return false;
    }

xKuemmelx wrote:

As far as I can see you are calculating either 2 or
4 pixels at one time in your routines (single or double
precision SSE/SSE2. I just wonder if there isn't a huge
penalty if the neighbour pixels have very different
depth of iterations, what sometimes is true especially
for the spiral areas in a mandelbrot fractal...?

                  Parallel computation  Serial computation
the first pixel   A - - - -             A
the second pixel  B B B B B               B B B B B
          seconds 1 2 3 4 5             1 2 3 4 5 6

xKuemmelx wrote:

When you go deeper and deeper in the fractal, is
single precision a problem, so that you got to do
double precision to get a proper result ?

Peter Kankowski wrote:

There is no problem, because operations are done in parallel.
Let's say you have 2 neighbouring pixels: the first
with 1 iteration, and the second with 5 iterations.
Imagine that one iteration takes 1 second (of course,
in the real program it takes less time). If you process
two pixels in parallel, you have to do 5 iterations
in 5 seconds. But it's the best you can do with this
two pixels, because processing them serially takes
1+5=6 seconds. Here is a simple diagram