DX11 DirectCompute Buddhabrot Demo

http://forum.beyond3d.com/showthread.php?t=50668

 

That would depend on the scoreboarding implementation though. I'm not familiar with Evergreen's implemention.

I think we probably don't need to use a real append/consume buffer though. A private array for each thread may be good enough. Or even better, a private shared array for each work group (the append/consume process can be done with atomic operations on shared memory). How do you think?

 

That download link doesn't seem to work in either firefox or IE - has the link changed guys?

 

Do you mean my download link? You may have to click into it, "Save Link" probably doesn't work.

Also I tried using shared memory to simulate an append/consume buffer, but it doesn't work very well. I increased the input size from 160x160 to 320x320, but the number of work groups remains the same, so each work group will do 4 times works. A shared memory buffer the size of 16*16*8 is used for append/consume buffer. The result is around 4100k samples/s.

Simply increase the input size to 320x320 runs at around 5700 k samples/s.

I suspect that because there needs to be a groupsync between the Iterate part and the IterateAndPlot part, threads with faster Iterates still have to wait for other threads. It actually makes the situation worse because in the original version only threads in the same wavefront have to wait, but now all threads in the same work group have to wait. Maybe a real append/consume buffer could help?

I also thought about another idea: in theory, the time it takes to run an IterateAndPlot is proportional to the IterateEscape parameter. That means, if we have collected all IterateEscape for each samples, it should be possible to sort them so the time spent on IterateAndPlot for each thread is more balanced.

The code is here (shared_idx, shared_x, shared_y, and shared_escape are groupshared memory):

Code:

	if(GI == 0) {
		shared_idx = 0;
	}
	
	GroupMemoryBarrierWithGroupSync();

	int y = DTid.y;
	int idx;
	for(int i = 0; i < 2; i++) {
		int x = DTid.x;
		for(int j = 0; j < 2; j++) {
			float2 random = randomInput.Load( uint3(x, y, 0) ).xy;
			float2 zRe;
			float2 zIm;
			zRe.x = random.x;
			zIm.x = random.y;
			random = randomInput.Load( uint3(x + nInputWidth / 2, y, 0) ).xy;
			zRe.y = random.x;
			zIm.y = random.y;
		
			// check whether sample complex number is in the mandelbrot set.
			int2 nIterationEscape;
			nIterationEscape  = Iterate2_unroll(zRe, zIm);
			
			if(nIterationEscape.x != nMaxIteration) {
				InterlockedAdd(shared_idx, 1, idx);
				shared_x[idx] = zRe.x;
				shared_y[idx] = zIm.x;				
				shared_escape[idx] = nIterationEscape.x;
			}
			
			if(nIterationEscape.y != nMaxIteration) {
				InterlockedAdd(shared_idx, 1, idx);
				shared_x[idx] = zRe.y;
				shared_y[idx] = zIm.y;
				shared_escape[idx] = nIterationEscape.y;		
			}
			
			x += nInputWidth / 4;
		}
		
		y += nInputHeight / 2;
	}
	
	GroupMemoryBarrierWithGroupSync();
	
	idx = GI;
	while(idx < shared_idx) {
		IterateAndPlot( shared_x[idx], shared_y[idx], nOutputWidth, nOutputHeight, shared_escape[idx]);
		idx += 16 * 16;
	}

 

Could someone with a GTX480 and the coding know how optimize it for the GF100 as it sems everything done so far has been to optimize it for cypress.

 

P(GTX480) * P(know how) = very small number

Most of the optimizations (except the vectorizing) are also valid for fermi, evergreen just benefits more from them (or you could say; needs them more). So I think it's mostly a matter of tweaking different sizes (and you more or less need a gf100 at hand for that).
But sure it would be interesting to see, to get the full picture.
This thread is already in line with our expectations that naive/generic code will usually run faster on gf100, while the tables are turned by a decent level of optimization, bringing cypress closer to it's peak rates.

 

Very true, I'd just like to see some scores from optimized code for both.

 

pcchen - no felix's original link returns a 404 error on the page with the download link. Is the latest code hosted anywhere else - link please!

 

You can get the original version from yakiimo's (the original author) website here:

http://www.yakiimo3d.com/2010/03/29/dx11-directcompute-buddhabrot-nebulabrot/

My modification is here:

http://sites.google.com/a/kimicat.c...a/2010_03_29_Buddhabrot_DirectCompute_mod.rar

 

I'm getting a 404 Not Found when trying to download. Any mirrors?

 

The author's original code is hosted at codeplex here

http://yakiimo3d.codeplex.com/releases/view/42716

 

seems no differance here for GTX 460