[cfe-commits] [cfe-dev] Cilk Plus Extension for Clang

[Chandler Carruth]

On Tue, Nov 6, 2012 at 7:35 PM, Hal Finkel <hfinkel at anl.gov> wrote:
> Fair enough. Unfortunately, although Chandler did touch on this, the relevant part of the criterion appears to be this, "Clang should drive the standard, not diverge from it. This criterion does not apply to all extensions, since some extensions fall outside of the realm of the standards bodies." The C/C++ committees have adopted library support for parallelism, and perhaps that is enough. If it is not enough (because of overheads, the inherent lack of semantics-aware optimizations, etc.) then we can consider other avenues. Cilk, or some derivative of it, was proposed to the committee, and rejected (according to Chandler's comments). Is the committee likely to adopt some other syntax-based approach in the near future? Or was this kind of extension decided to be out-of-scope for the time being. If it was decided to be out-of-scope, then it qualifies for the exemption.

Doug took all the words out of my mouth for most of this, but I'd like
to clarify what I mean here in particular.

The Cilk proposal was not rejected. I don't really think there has not
been a formal proposal per se... Folks presented Cilk (and many other
technologies in the industry) to the committee to try to help inform
it as to what solutions were out there, and what they might look as
part of standard C++. They've even presented different aspects or
possibilities surrounding a few of the technologies to try to get more
ideas going.

Currently the committee has been giving feedback on exactly how
different aspects would or wouldn't fit into the standard, etc., and
folks seem to be looking into how the fundamental capabilities of
something like Cilk could be best integrated with the language as a
whole. That's what I was trying to say -- the only thing that seems
clear is that we don't yet have a clear picture of what will end up
being in the standard. =] That said, I'm personally confident that
these forms of parallelism *are* in scope for the standard, and
reasonably optimistic that we'll get something figured out in the
C++17 timeframe.