In my previous blog I talked about how in Visual Studio 11 we have eliminated the need to convert your Visual Studio 2010 C++ projects in order to adopt the new IDE. The blog also mentioned that you can build your projects using Visual Studio 2010 compiler (tools and libraries) from within Visual Studio 11 using the multi-targeting feature. This means while you adapt to using the new compiler and while your 3rd party vendors provide you with binaries compatible with the Visual Studio 11 compiler (tools and libraries) you can leverage the new Visual Studio 11 IDE without disrupting your ship cycle. Just set the platform toolset property to v100 in the property pages (requires Visual Studio 2010 to be installed side-by-side with Visual Studio 11). Since no upgrade of your project file is necessary you can continue to load the project/solution in Visual Studio 2010 as well.
We have recently received feedback from a number of customers about the inability to build binaries that run on Windows XP with the Beta version of the Visual Studio 11 compiler and libraries. This is because the C++ compiler and libraries in Visual Studio 11 Beta leverages platform capabilities only available in Windows Vista and higher. However, if support for Windows XP targeting is important to you, then you can use Visual Studio 11 Beta’s multi-targeting capability described above in order to employ the Visual Studio 2010 compiler and libraries to build applications and libraries than execute on Windows XP. This enables you to enjoy the new features of the Visual Studio 11 Beta environment without sacrificing backward compatibly in your applications!
Thanks for the frank feedback, everyone. I definitely hear the desire for XP targeting support in Dev11. While I don't have any news to announce on this front, I do want to better understand what problems this capability would help you solve.
Let's say for the sake of argument that the C++ compiler in Dev11 Beta enabled you to target XP. Reading through this thread, it sounds like the primary value this would create for folks is the ability to use Dev11's better support for the C++11 language standard while targeting Windows XP and higher. I also understand that it is much less convenient use two different compilers if you want to build apps that are XP and higher in Dev11. These two things certainly make sense to me, and I'd like to learn more about other capabilities that are important to you.
So, apart from C++11 support and the single compiler convenience factor, are there other scenarios that that support for XP targeting in the Dev11 compiler would light up for you? As you may know, most of the new value in the Dev11 C++ compiler focuses on modern hardware (e.g., vectorization with SSE or GPGPU with C++ AMP) or modern platform (i.e., C++/CX, Windows 8 Metro). None of this stuff wouldn't be usable from Windows XP (at least for apps that need to run on all of the hardware on which XP runs). But perhaps there are other capabilities that you're seeking.
Director of Program Management, VC++
Thank you for starting a discussion with the Community!
> But perhaps there are other capabilities that you're seeking.
For me, the main goals would be:
1) Improved standard compatibility (C++11. There can't be a technical reason for not working on XP)
2) Better optimization (Yes, older operating systems sometimes can't benefit from them, when they for example depend on special instruction sets like SSE. But maybe there are for example also better optimization routines that don't depend on such instruction sets or on GPGPU. They would work on XP, too...)
3) Faster compilation (I don't know if there are improvements in that direction, but if so: That is independand from target OS, but on host OS. That the compiler doesn't run on XP is no big problem)
Thank you for starting this discussion. Feels great to know that our input is valued after all.
For me, the most important features in VS11 that I would want to use in combination with XP targeting are:
- Improved C++11 support (including the incremental updates planned for the VC++ compiler)
- Concurrency runtime support (i.e. the ConcRT headers in addition to <thread> et al.)
As to auto-vectorization, I would appreciate it being enabled when /arch:SSE is in use. About 35% of our customers are still on XP SP3, but nearly all of them have SSE capable processors.
> As you may know, most of the new value in the Dev11 C++ compiler focuses on modern hardware (e.g., vectorization with SSE or GPGPU with C++ AMP) or modern platform (i.e., C++/CX, Windows 8 Metro).
Most? Really? The *majority* of us do not care about any of that.
1) Metro looks like a dead-end on desktops, which makes C++/CX mostly irrelevant in the *years* until Win8 tablets actually have a measurable market share.
2) Auto-vectorization is just an implementation detail regarding better code-gen, which no one is really complaining about anyway.
3) C++AMP's potential demographic is already generally happy with CUDA and OpenCL. MS' reinventing the wheel here isn't really exciting anyone outside of MS.
What the *majority* of us want is improved C++11 support. Period. Unless C++11 improvements will be backported into a VC++ 2010 service pack, VC++11 is simply not compelling enough to abandon 25+% of our userbase. The idea that this might be new news to MS is scary at best.
For me the most important things would be the new C++11 language features + standard library and being able to use them when targeting Windows XP, the CRT must run on Windows XP. Concurrency Runtime that supports Windows XP is also very important.
I don't care about MFC, C++/CX or Metro. Auto vectorization and C++AMP are nice, but being able to target Windows XP using C++11 is still 100 times more important. Also, I think most XP machines of these days can run SSE instructions.
Thanks for asking for our opinions.
C++11 is the #1 reason. Allow us to use the VC++ 11 compiler to target XP SP3 and above and you will have covered the vast majority of us.
Also, the resource compiler is in need of some work :-) UTF-8 support would be nice.. Just sayin'.
Plus: any & all run-time bug fixes, optimizations and improvements
Since VS6 MSFT has chosen to NOT ship multiple service packs. Now all we get is 1 minimal SP, and after that we need to pay & upgrade to the latest version of VS. (That seems how MSFT runs VS: "won't fix in this version")
Agree with all the other comments.
I simply want C++11 support in the compiler with the ability to target XP and above.
Let's see, of course the really big issues are what you already mentioned: my entire team is itching to use more C++11 features, but working on a cross-platform product, we're held back by the lowest common denominator (and you guess which compiler *that* is).
The improved static analysis (and its availability in all editions, not just Ultimate) is a big factor as well. We'd really like to be able to throw that at our code.
As our product is very performance-critical in places, the improvements to codegen would be very welcome (some parts use hand-written SSE, and I don't see that changing, but auto-vectorization would be very nice for the rest of our code (and I don't quite understand why you seem to imply that it wouldn't be possible on XP)
AMP would be interesting. I'm not sure how much it's realistic for us to use it but it's something we're interested in investigating.
And because it's a big codebase (around 150 projects, and it takes around 40 minutes for a full build), the build time improvements and a faster, more scaleable IDE would be nice.
And frankly, having to use more than one compiler on Windows is pretty much a no-go. We currently have some projects using VC2005, and the majority on 2010, and it causes us *a lot* of pain. We're working to get rid of the 2005 cruft soon, and there is no way we're going to reintroduce multiple compilers on Windows. Our test matrix is big enough already (with several supported product versions, three OSes, GCC and MSVC compilers and a few other variables).
Metro? Well, perhaps. We're sort of in exploratory mode regarding tablets, right now. An iPad port looks likely, but if Metro takes off, a Windows tablet might be an option too. But again, we're not going to fork our build system and start using two separate compilers just to achieve that.
Note that we don't need XP support for *all* of this. We build a couple of different products on Windows, and some are only supported on Win7 and up, but another has to support XP, and that won't change for a while.
So it's essential that we can use the VC11 compiler to target XP. Anything it can do when targeting Vista or Win7 is a nice bonus, and we'll make use of that as much as possible, but we *also* need to be able to target XP.
So yeah, we're actually interested in a lot of different aspects of VC11, but ultimately, the #1 priority is that we get the convenience of a single Windows toolchain, with a single compiler version, and that we get as good C++ support as possible. Since expecting the bugs in VC10's C++11 features to be fixed is obviously unrealistic, we would like to be able upgrade to a newer compiler.
Which brings us to one last reason we'd like to upgrade if we could: those tantalizing rumors that VC11 will actually be *supported*. That bugs will be fixed *without* having to wait for VC12, that the compiler might actually be improved, that new features might be added.
That's about 15 years overdue, but if you're serious about it, we'd quite like to benefit from it.
Which means we need to migrate to VC11, which means that VC11 needs to support Windows XP.
> As you may know, most of the new value in the Dev11 C++ compiler focuses on
> modern hardware (e.g., vectorization with SSE or GPGPU with C++ AMP) or modern
> platform (i.e., C++/CX, Windows 8 Metro).
WRONG. The single "new value" in Dev11 C++ compiler is the support for C++11.
As a side note, I think you're greatly overestimating the interest in Metro among C++ users.
"So, apart from C++11 support and the single compiler convenience factor, are there other scenarios that that support for XP targeting in the Dev11 compiler would light up for you?"
That seems to imply that those two things alone aren't enough. I hope that is not what you are implying, because those two things alone are DEFINITELY enough to NOT DROP SUPPORT FOR AN OS THAT'S GOING TO BE OFFICIALLY SUPPORTED FOR TWO MORE YEARS.
Fine, here's another: being able to use the currently supported compiler to build applications that run on all currently supported OSes.
Unless you're going to start releasing more service packs for VC++ 10, then it's a dead end. We can't get any more fixes to the compiler, or the language support. Remember, this is supposed to be the C++ Renaissance here, don't kill it. If we can't support the OSes that our customers are using, we can't upgrade. It's plain and simple. I just don't understand why you can't seem to understand this.
"As you may know, most of the new value in the Dev11 C++ compiler focuses on modern hardware (e.g., vectorization with SSE or GPGPU with C++ AMP) or modern platform (i.e., C++/CX, Windows 8 Metro). None of this stuff wouldn't be usable from Windows XP (at least for apps that need to run on all of the hardware on which XP runs)."
Great, I'm glad to hear that all of this stuff will be usable from Windows XP. Now you have no reason not to support XP.
So, simply convert the hard bindings to Windows Vista+ APIs from the MFC and CRT binaries, and use explicit linking like you've done in every past version when you wanted to use APIs that are on newer versions of the OS than the ones currently under support, and we'll be all set. It's already been proved that there is no technical reason not to support it. The only other possible reason that we can see is that you don't care about making us successful, you just want to try to use us to force our customers to upgrade. It's not going to work. If we drop support for the OSes that our customers are using, then they'll be the ones to choose not to upgrade to the new version of our product.
Oh, wait, you meant that none of this stuff WOULD be usable. Well, let's look at that argument. SSE works on XP. C++ AMP requires Windows 7. C++/CX and Windows 8 Metro require Windows 8.
Nope, that argument doesn't work that way either. If OS support for those things were required, then the compiler could only support Windows 8, and it supports Windows 7 and Windows Vista. Only one of those things is available on Windows Vista, and it is also available on Windows XP. So there is nothing in that list that supports eliminating Windows XP while keeping Windows Vista and Windows 7.
I appreciate the well-thought-out posts, everyone. It sounds like C++11 and simplicity of a single tool chain are the big value drivers. We get that C++11 is important in the context of being able to maintain a modern, multi-platform code base. Dev11's static analysis and general improvement in generated code quality also seem valuable to folks. A couple of comments on specific posts:
Philipp: Build throughput of Dev11 relative to Dev10 will depend on individual cases -- sometimes it's a win and sometimes not. We're doing some analysis here, and we'll post the results on the blog soon.
jalf: You are correct that you can use SSE on machine running XP -- my point was that you wouldn't want to do this if you wanted your software to run on all XP machines, as XP's minimum hardware requirements don't include an SSE-capable CPU.
(As a general side-note to the above, SSE code is generated by the automatic vectorizer, which is a source of a lot perf goodness in the Dev11 compiler)
pingpong: At the risk of splitting hairs, I was speaking specifically about the compiler in the bit you quoted. The bulk of the new C++11 work in Dev11 is in the standard libraries rather than the compiler. I get your point, though; C++11 is important to you. :)
Thanks again for the continued feedback. I sincerely appreciate the engagement.
Hi, GregM: I am not making a value judgment on those two reasons being compelling or not -- I just wanted acknowledge my understanding of those benefits, and I was asking folks for their thoughts on other benefits that were important to them. :) And see my comment to jalf above clarifying my point on using SSE with XP. I'm certainly not here to debate or defend of the lack of XP targeting in Dev11 Beta; I'm here to understand the specific benefits customers are seeking with XP targeting.
> At the risk of splitting hairs, I was speaking specifically about the compiler in the bit you quoted. The bulk of the new C++11 work in Dev11 is in the standard libraries rather than the compiler.
Currently this is the case, yes, but we're all also counting on the promised out-of-band language feature updates that have been promised for Dev11.