Andy Ayers: Understanding the Phoenix Compiler Framework

Posted By: Charles | Apr 9th @ 12:19 PM

The compiler gurus over in C++ World (we spend a lot of time in building 41) have just released the latest CTP of the Phoenix Compiler Framework. It's been a while since we've learned about Phoenix here on Channel 9 so we thought it necessary to find out what's going on with the soon-to-be de facto compiler technology for all of Microsoft's products.

Andy Ayers is an Architect on the Phoenix team. He sits down with us to dig into the details of Phoenix and address it's current state, history and future (no whiteboarding here, but this is still quite deep. There is a cool demo at the end of the interview.) . It's very interesting to note that the Phoenix team has tested the scalability and power of their pluggable (extensible) compiler framework on the likes of Windows. Turns out Phoenix handles such a large task (compiling Windows) very well. This new compiler technology has been designed with many-core in mind. This means Phoenix is our most parallelized compiler which adds up to shorter compilation time. As usual, the C++ team is ahead of the curve when it comes to preparing for the concurrent future.

Tune in and learn all about the future of Microsoft's compiler technology from one of the minds behind it all. The future is very bright indeed!

Enjoy!

Low res version here.

Tags: C++, Compilers, Phoenix Framework

Rating:

Views (15,939)

Comments (19)

Downloads

GamlerHart

This "show-me-the-path-of-the-variable-setting" is REALLY cool. How many time you've debuged the same small function, because you got another value than expected. With this feature, you can quickly see it, without re-running the function. You've an overview how you landed at the state you're now in.

Sadly, I'm not really in the C++/native word, but in the Java / Managed World.

staceyw

GamlerHart wrote:

This "show-me-the-path-of-the-variable-setting" is REALLY cool. How many time you've debuged the same small function, because you got another value than expected. With this feature, you can quickly see it, without re-running the function. You've an overview how you landed at the state you're now in.

Sadly, I'm not really in the C++/native word, but in the Java / Managed World.

I like that too. And ability to Step backwards and reverse the state would be so cool.

Look forward to new compiler in the product. Thanks much folks.

BTW - small correction. The managed class is "StringBuilder" (not stringbuffer).

silverfrost

Charles: Thank you for the continued low res versions of your videos, much appreciated Big Smile

AndyC

The raising an executable to IR sounds very interesting. Presumably this could allow you to migrate executables to another CPU architecture (much like Rosetta in MacOS) if that ever became an issue for Windows.

AndyA

One of the cool things about Phoenix is that it blurs the line between managed and native code in a number of interesting ways.

So, if you're into managed code, you'll be happy to hear that the dynamic slice tool works on managed code too.

AndyA

staceyw wrote:

GamlerHart wrote: This "show-me-the-path-of-the-variable-setting" is REALLY cool. How many time you've debuged the same small function, because you got another value than expected. With this feature, you can quickly see it, without re-running the function. You've an overview how you landed at the state you're now in.

Sadly, I'm not really in the C++/native word, but in the Java / Managed World.

I like that too. And ability to Step backwards and reverse the state would be so cool.

Look forward to new compiler in the product. Thanks much folks.

BTW - small correction. The managed class is "StringBuilder" (not stringbuffer).

Reverse debugging is indeed really cool, but there's a sizeable gap between what we can do with slicing and actually being able to run the program backwards. Still, the idea is compelling...

We should be dislosing release plans sometime in the not-too-distant future. But you don't have to wait until then to have fun with Phoenix -- download the SDK and you'll get a version of Phoenix that plugs right into the VS2008 C++ toolchain.

Thanks for the correction.

AndyA

AndyC wrote:

The raising an executable to IR sounds very interesting. Presumably this could allow you to migrate executables to another CPU architecture (much like Rosetta in MacOS) if that ever became an issue for Windows.

Binary translation is certainly doable, and the machine-specific part of Phoenix is extensible (though this is not yet as easy to do as we would like it to be). Sounds like a fun project for somebody to try...

esoteric

Having processor makers produce plugins for Phoenix sounds quite compelling, for Phoenix itself, Microsoft, the processor makers and the users.

And it would be great with more static IL optimizations. On the other hand, in the parallel world of the future, there should be enough cores to continuously GC, profile and analyze code, so one wonders how much Phoenix can adapt to dynamic compilation and analysis demands.

Anyway, cool stuff.

dumian

super cool, i already have the previous build, is quite an step forward
Wink