"The plural of anecdote is not data."
- Frank Kotsonis
More pages: 1 ... 7 8 9 10 11 12 13 14 15 16 17 ... 21 ... 31 ... 41 ... 48
Whoha, I found a compiler bug
Thursday, February 18, 2010 | Permalink

I gave Visual Studio 2010 RC a few quick runs and while doing so I noticed that it doesn't always generate optimal code with the StringHash code I mentioned recently. Often it behaves just like you expect and outputs the constant directly, but it happens that it generates some clearly suboptimal results. This is a call to Context::SetConstantBuffer():

mov eax, dword ptr [ebx+9D0h]
push eax
push ecx
mov eax, esp
mov dword ptr [eax], 0
mov dword ptr [eax], 54h
mov dword ptr [eax], 541514h
mov dword ptr [eax], 29C53055h
mov dword ptr [eax], 77DBE55Eh
mov dword ptr [eax], 647B726Bh
mov dword ptr [eax], 2CCC28C8h
mov dword ptr [eax], 2F060985h
mov dword ptr [eax], 9C015834h
mov dword ptr [eax], 0BC88B513h
mov dword ptr [eax], 1AB79019h
mov dword ptr [eax], 23457696h
mov dword ptr [eax], 24AE2F4Ch
mov dword ptr [eax], 3629A415h
mov dword ptr [eax], 0F8546197h
mov dword ptr [eax], 7E5B047Ch
mov dword ptr [eax], 1CE21AF8h
mov dword ptr [eax], 369CA37Ah
mov dword ptr [eax], 14063B6Fh
mov dword ptr [eax], 28F7A0BFh
push esi
mov dword ptr [eax], 0B5AF8F68h
call Context::SetConstantBuffer (404750h)

Clearly there's a lot of superfluous writes that should have been optimized away. At first I thought this was a new bug in Visual Studio 2010, so I tried it in Visual Studio 2008 and it did the same thing. It's unclear why this happens, or what triggers this behavior, but I just noticed it happening in a certain location in my program.

So I rewrote the StringHash() constructor in this way, which appears to fix the problem:

StringHash(const char (&str)[4])
{
    uint32 hash0 = 0;
    uint32 hash1 = hash0 * 65599 + str[0];
    uint32 hash2 = hash1 * 65599 + str[1];
    m_Hash = hash2 * 65599 + str[2];
}

[ 9 comments | Last comment by Aslan Dzodzikov (2010-05-14 18:43:42) ]
DirectX SDK February 2010 is out
Saturday, February 6, 2010 | Permalink

The biggest news is that they have made some very nice improvements to PIX, such as much improved support for DX11, but also that we can finally view depth-stencil buffers in DX10/DX11 apps, a features that has been sorely missing for a long time. Also, compressed sRGB textures can now be viewed, which is something I have wished for very much during development of Just Cause 2 since we use these formats a lot.

Being able to switch to REF device is a very cool feature too. It's very good for debugging if you've been able to capture a graphical artifact that you suspect is a driver bug. By switching to REF and comparing you can see if it's due to the driver or something wrong with your code. Running your whole game through REF is usually not an option, but playing back a captured frame on the other hand is much more manageable.

[ 1 comments | Last comment by Seth (2010-02-08 04:06:37) ]
Vehicular Stunts Developer Diary HD
Sunday, December 6, 2009 | Permalink

More Just Cause 2 material has hit the web. Well worth checking out.

Also, the game also got an official release date recently. It will be available in March 23 in North American and March 26 elsewhere.

[ 7 comments | Last comment by john cooper (2010-01-25 14:51:35) ]
Framework4 update
Thursday, November 5, 2009 | Permalink

I haven't mentioned the new framework I'm working on in a while, mostly because progress has been slow and I've been occupied with other things. Just wanted to give a brief mention of a neat trick I've implemented recently. In my framework I try to strike some kind of balance between ease of use and readability versus performance. Most of the time my demos are not very CPU heavy at all, so the CPU-side performance part isn't all that relevant, but it's always nice to have low overhead, just because it feels good. In Framework4 I've taken some steps to keep the overhead down. Something I usually do for readability is to set textures and other resources by name using strings, like so:

context->SetTexture("Tex", m_Texture);

This makes the code very readable and it's easy to see the mapping from the code to the shader. Unfortunately, lookups by a bunch of strcmp() is not the fastest way to find the corresponding texture unit index, even though it doesn't have to be terribly slow. A faster way is to use a precomputed hash value and do a lookup with that instead. I still want to use the same syntax though. What I ended up doing was changing const char * to StringHash, which is a class containing only a uint32 value, so for all practical purposes, it's a uint32 when compiled with optimizations. StringHash has loads of constructors. One for each length of the string I need, like so:

StringHash(const char (&str)[2]);
StringHash(const char (&str)[3]);
StringHash(const char (&str)[4]);
StringHash(const char (&str)[5]);
...
StringHash(const char (&str)[21]);

This covers all strings up to 20 characters, which should be enough for resource names. Each constructor contains the unrolled code for generating the hash, for instance:

StringHash(const char (&str)[4])
{
    m_Hash = 0;
    m_Hash = m_Hash * 65599 + str[0];
    m_Hash = m_Hash * 65599 + str[1];
    m_Hash = m_Hash * 65599 + str[2];
}

The hash function itself is not very important, I chose this one because it came up early on a google search. So when I make a SetTexture() call, I can call it with a constant string directly, which in C++ means it'll look for a way to convert the const char array to a StringHash, and finding a matching constructor it will use that to construct the StringHash object for me. Given the compile-time constant string and the simple unrolled code, any decent compiler will boil all this down to the resulting hash code when compiled with optimizations, and the runtime cost is essentially the same as if I would have written it like this:

context->SetTexture(0x29C22FA7, m_Texture);

A sneak peek at the assembly code we find the resulting hash inlined as an intermediate constant:

mov dword ptr [eax], 29C22FA7h
call Context::SetTexture

It will of course still be faster to just call SetTexture() with an index directly instead of the name, but this should narrow the gap somewhat.

[ 27 comments | Last comment by Aslan Dzodzikov (2011-05-20 14:31:13) ]
Real-life low-polygon head
Tuesday, November 3, 2009 | Permalink

This has got to be the coolest Halloween costume ever!

[ 1 comments | Last comment by FMoreira (2009-11-04 00:08:16) ]
Exclusive No Ordinary Mission Trailer HD
Friday, October 30, 2009 | Permalink

Sorry for the lack of updates here lately, I haven't had much time to work on any of my personal projects or comment on the news flow. But another trailer from the game I'm working on has hit the web, so check it out.

[ 8 comments | Last comment by Humus (2009-11-13 18:40:44) ]
The Island of Panau Developer Diary HD
Friday, October 9, 2009 | Permalink

Another Just Cause 2 video has found its way onto the intertubes.

[ 8 comments | Last comment by mark (2009-11-26 21:43:41) ]
New demo
Sunday, October 4, 2009 | Permalink

There's a new demo available that illustrates a technique for seamless decals on arbitrary geometry. Shoot a paint splash in front of you by clicking the mouse. Select colors on the F1 dialog. It's hours of fun!

This technique will be featured in the upcoming GPU Pro book I mentioned in the previous post. In the "Volume Decals" article I cover all the dirty details of the inner workings as well as suggestions for alternative implementations and extensions.

[ 6 comments | Last comment by Black Knight (2009-11-03 02:20:38) ]
More pages: 1 ... 7 8 9 10 11 12 13 14 15 16 17 ... 21 ... 31 ... 41 ... 48