Was looking at the code last night - but it looks very neat as it is, and theres no obvious cpu stall points that i can see.. Might be worth removing the TGA output code temporary and comparing them again (make sure its not just that you're writting the output file in an unoptimal way - although you're doing one big write, which should be fast - but worth testing to make sure that this is not the cause - just remember to take the TGA output out from both the C and asm versions (wouldnt be fair to only take it out of the asm version ))

I was going to use callgrind (from the valgrind package/suite of tools) to try to profile it and see where the slowest sections are.. you may want to try it on both the C and asm versions, and see what it says about execution times of loops/functions.

I'll let you know if i find anything obvious - but as i say, the code looks really good.. I worry it might be an alignment thing since its SSE - but you seem to have done all the alignment required - so would be weird for it not to work well.

EDIT: Well valgrind wasnt useful. It only seperates at call level, not loop level. So for your program (which has very calls), its way too vague. Might have to do it manually by adding calls to the clock_gettime syscall to read the CLOCK_PROCESS_CPUTIME_ID clock which will give "High-resolution per-process timer from the CPU.", so the same as the time command, but can be inserted in various places in your code to find what's taking time. Just careful because this syscall itself will add time to the process's execution time.. so you may only want to put one, moving it around, and only counting UP to this syscall.

How much is the compiler faster? Twice as fast or 10% faster? Depending on that, we can start to search for reasons.

                ; dz = 2.0 * z * dz + (1.0,0.0)
                movaps      xmm0,xmm14
                movaps      xmm1,xmm15
                shufps      xmm0,xmm0,01000100b
                shufps      xmm1,xmm1,00010100b
                mulps       xmm0,xmm1
                xorps       xmm0,dqword [g_inv_y_sign]
                movaps      xmm1,xmm0
                shufps      xmm0,xmm0,00001000b
                shufps      xmm1,xmm1,00001101b
                addps       xmm0,xmm1
                addps       xmm0,xmm0
                addss       xmm0,[g_1_0]
                movaps      xmm15,xmm0
                ; z = z * z + c
                movaps      xmm0,xmm14
                movaps      xmm1,xmm0
                shufps      xmm0,xmm0,00000100b
                shufps      xmm1,xmm1,01010100b
                mulps       xmm0,xmm1
                xorps       xmm0,dqword [g_inv_y_sign]
                movaps      xmm1,xmm0
                shufps      xmm0,xmm0,00001000b
                shufps      xmm1,xmm1,00001101b
                addps       xmm0,xmm1
                addps       xmm0,xmm13
                movaps      xmm14,xmm0    

randall, thanks for the info on the gpu.
I feel I should help you alittle with your cpu version.
First I should mention
http://board.flatassembler.net/topic.php?t=12722
where I and Kuemmel have creaded a super fast mandelbrot renderer for windows.
For example, the image shown on that page is 1080x1920 and took just 0.05 sec.
If you want to increase the speed you have three independent options:
- multithread (use multiple coures)
- vectorize (use mulps instead of mulss)
- parallelize (unroll loops and handle multiple points per loop)
The downside is that is going to increase the complexity of your code...