I've been working on some VERY calculation-intensive code in (gasp!) C#.
I'm building a GPGPU implementation of FDTD for optical modeling. On a small (128 processor) cluster, many of our simulations take weeks to run. The GPU implementations, however, tend to run about 50x faster - and that's on a consumer-grade NVidia card. We now have a server with two GTX295 dual-processor cards (several hundred cores), and are getting some Teslas soon.
How does this pertain to your language? In the same way that the C++ FDTD code we were using before was CPU-bound, these are GPU-bound, so the (very small) horsepower difference of managed vs native code doesn't ever come into play. The C# app acts as a conductor - loading OpenCL kernels, passing data to and from the GPUs, providing the user interface, reporting, etc. - all tasks that are a pain in the ass in C++.
In years past, the performance difference between managed and unmanaged code was significant enough that it was sometimes worth putting up with C++'s terrible object model to get the extra few percent of speed. These days, the development cost of C++ vs C# far outweighs the benefits for most applications.
Also, most of your performance difference isn't going to come from your choice of language, but from the skill of your developer. A few weeks ago, I moved a single division operation from the inside of a triple-nested (3D array traversal) loop, which reduced execution time for a given computational domain by 15%. That's a result of processor architecture: division is slow, which is one of those faces that you just need have picked up somewhere.