<?xml version="1.0" encoding="UTF-8"?><!-- generator="wordpress/1.5.2" -->
<rss version="2.0" 
	xmlns:content="http://purl.org/rss/1.0/modules/content/">
<channel>
	<title>Comments on: Gcc vs. Users</title>
	<link>http://www.airs.com/blog/archives/81</link>
	<description>Ian Lance Taylor</description>
	<pubDate>Wed,  8 Oct 2008 06:10:30 +0000</pubDate>
	<generator>http://wordpress.org/?v=1.5.2</generator>

	<item>
 		<title>Comment on Gcc vs. Users by: Ian Lance Taylor</title>
		<link>http://www.airs.com/blog/archives/81#comment-6595</link>
		<pubDate>Sat, 10 Nov 2007 02:28:43 +0000</pubDate>
		<guid>http://www.airs.com/blog/archives/81#comment-6595</guid>
					<description>Thanks for the note.  I agree that it would be useful to have somebody to keep issues running more smoothly both inside and outside of the project.  It's a difficult and time consuming role, though, and probably not a very rewarding one for most people.  It's not one which any company is likely to pay for, except conceivably for an organization like OSDL.  Also, the only way for that person to really change things would be to get gcc developers to make changes in some cases, and we know that that can also be very hard.  So while I hope that some such person appears, I don't see how we can count on it or plan for it.</description>
		<content:encoded><![CDATA[	<p>Thanks for the note.  I agree that it would be useful to have somebody to keep issues running more smoothly both inside and outside of the project.  It&#8217;s a difficult and time consuming role, though, and probably not a very rewarding one for most people.  It&#8217;s not one which any company is likely to pay for, except conceivably for an organization like OSDL.  Also, the only way for that person to really change things would be to get gcc developers to make changes in some cases, and we know that that can also be very hard.  So while I hope that some such person appears, I don&#8217;t see how we can count on it or plan for it.
</p>
]]></content:encoded>
				</item>
	<item>
 		<title>Comment on Gcc vs. Users by: Manu</title>
		<link>http://www.airs.com/blog/archives/81#comment-6566</link>
		<pubDate>Fri, 09 Nov 2007 17:38:40 +0000</pubDate>
		<guid>http://www.airs.com/blog/archives/81#comment-6566</guid>
					<description>Hi Ian,

I think that the key points is people talking past each other. I understand that GCC developers have little time but sometimes I think there is a lack of explanations and patience. 

Saying &quot;that is undefined by the standard&quot; or &quot;that is allowed by the standard&quot; does not satisfy users. And most of the time the *real* reasons are far simpler and easier to understand if explained properly. Typically they are that doing otherwise: &quot;will break other people's code&quot;,  &quot;will reduce performance for other people's code&quot;, &quot;will reduce the performance of gcc&quot; or &quot;will add excessive complexity to gcc&quot;. Or simply, &quot;sorry, we would like to, but we cannot do that yet&quot;.

I don't think GCC needs someone in charge, a Project Leader. But GCC needs someone that can speak for GCC. Someone that has time to go in private with people (users and developers) and work out what are the real issues, which are the possible solutions and how to find a compromise. Someone that acts as a middle-man between busy GCC devs and users and also sometimes between GCC devs when things go a bit personal (and that has happened in a few occassions) in order to avoid people talking past each other.</description>
		<content:encoded><![CDATA[	<p>Hi Ian,</p>
	<p>I think that the key points is people talking past each other. I understand that GCC developers have little time but sometimes I think there is a lack of explanations and patience. </p>
	<p>Saying &#8220;that is undefined by the standard&#8221; or &#8220;that is allowed by the standard&#8221; does not satisfy users. And most of the time the *real* reasons are far simpler and easier to understand if explained properly. Typically they are that doing otherwise: &#8220;will break other people&#8217;s code&#8221;,  &#8220;will reduce performance for other people&#8217;s code&#8221;, &#8220;will reduce the performance of gcc&#8221; or &#8220;will add excessive complexity to gcc&#8221;. Or simply, &#8220;sorry, we would like to, but we cannot do that yet&#8221;.</p>
	<p>I don&#8217;t think GCC needs someone in charge, a Project Leader. But GCC needs someone that can speak for GCC. Someone that has time to go in private with people (users and developers) and work out what are the real issues, which are the possible solutions and how to find a compromise. Someone that acts as a middle-man between busy GCC devs and users and also sometimes between GCC devs when things go a bit personal (and that has happened in a few occassions) in order to avoid people talking past each other.
</p>
]]></content:encoded>
				</item>
	<item>
 		<title>Comment on Gcc vs. Users by: Ian Lance Taylor</title>
		<link>http://www.airs.com/blog/archives/81#comment-6195</link>
		<pubDate>Fri, 02 Nov 2007 04:17:19 +0000</pubDate>
		<guid>http://www.airs.com/blog/archives/81#comment-6195</guid>
					<description>The global write maintainers are in charge in a sense, in that they can move gcc in whatever direction they choose.  However, in practice, they don't.  Most of the global write maintainers are inactive.  The most active global write maintainer is Mark Mitchell, and he confines himself to the C++ frontend.  While the global write maintainers have veto power, they don't use it.  The closest they ever come is a pocket veto: some patches never get approved.

So I would say that while the structure of gcc permits the global write maintainers to be in charge, in practice they are not.

The steering committee has evidently decided not to create any new global write maintainers.  Perhaps they are concerned about this very issue.</description>
		<content:encoded><![CDATA[	<p>The global write maintainers are in charge in a sense, in that they can move gcc in whatever direction they choose.  However, in practice, they don&#8217;t.  Most of the global write maintainers are inactive.  The most active global write maintainer is Mark Mitchell, and he confines himself to the C++ frontend.  While the global write maintainers have veto power, they don&#8217;t use it.  The closest they ever come is a pocket veto: some patches never get approved.</p>
	<p>So I would say that while the structure of gcc permits the global write maintainers to be in charge, in practice they are not.</p>
	<p>The steering committee has evidently decided not to create any new global write maintainers.  Perhaps they are concerned about this very issue.
</p>
]]></content:encoded>
				</item>
	<item>
 		<title>Comment on Gcc vs. Users by: tromey</title>
		<link>http://www.airs.com/blog/archives/81#comment-6141</link>
		<pubDate>Wed, 31 Oct 2007 18:18:09 +0000</pubDate>
		<guid>http://www.airs.com/blog/archives/81#comment-6141</guid>
					<description>I do tend to talk about the negatives more, because they are the things requiring change.  Acceptance of their existence is the first step... but naturally, when discussing solutions I think we must also try to avoid breaking the parts of the process that work well.  This isn't easy, since easy-to-fix problems tend to be fixed immediately.

The tone of the recent discussion says to me that the bridges have already been burnt.  Kernel developers, at least the vocal ones, have given up on GCC.  My concern is that we're in the process of eroding the trust that other developer communities have.  (Speaking of which, I also hear many complaints about C++ -- ABI breakages from several years ago still get complaints.)

I agree that the lack of a central maintainer is a problem.  It is hard to picture who could fill that role, though, especially given GCC's history.  The abrasive nature of some people on the GCC list partly stems from this problem; although things have been better in recent years, the community would be a bit better off if it required people to temper their tone a bit.

FWIW I don't really agree that nobody is in charge of GCC.  This is what GCC developers say, but in reality the global write maintainers have an enormous say over the direction of the compiler -- at least in terms of veto power.  I think there are social reasons that this is not openly discussed, but it doesn't make it less true :)

I dunno, maybe I'm looking for doom.  I'm not as optimistic about GCC as you seem to be, but neither am I overly pessimistic.  On the plus side I think GCC is fairly open technically -- everybody knows there are problems but there generally isn't much resistance when someone codes up an improvement.  General cleanups are under-invested, but that seems to be an industry-wide phenomenon.

On the minus side I would put certain developers' email styles, an occasionally unwieldy patch approval process (or, really, too few maintainer), and lack of transparency and change in the SC (though I liked what I heard from the SC at the summit, and this made the committee not seem quite as bad).</description>
		<content:encoded><![CDATA[	<p>I do tend to talk about the negatives more, because they are the things requiring change.  Acceptance of their existence is the first step&#8230; but naturally, when discussing solutions I think we must also try to avoid breaking the parts of the process that work well.  This isn&#8217;t easy, since easy-to-fix problems tend to be fixed immediately.</p>
	<p>The tone of the recent discussion says to me that the bridges have already been burnt.  Kernel developers, at least the vocal ones, have given up on GCC.  My concern is that we&#8217;re in the process of eroding the trust that other developer communities have.  (Speaking of which, I also hear many complaints about C++ &#8212; ABI breakages from several years ago still get complaints.)</p>
	<p>I agree that the lack of a central maintainer is a problem.  It is hard to picture who could fill that role, though, especially given GCC&#8217;s history.  The abrasive nature of some people on the GCC list partly stems from this problem; although things have been better in recent years, the community would be a bit better off if it required people to temper their tone a bit.</p>
	<p>FWIW I don&#8217;t really agree that nobody is in charge of GCC.  This is what GCC developers say, but in reality the global write maintainers have an enormous say over the direction of the compiler &#8212; at least in terms of veto power.  I think there are social reasons that this is not openly discussed, but it doesn&#8217;t make it less true <img src='http://www.airs.com/blog/wp-images/smilies/icon_smile.gif' alt=':)' class='wp-smiley' /> </p>
	<p>I dunno, maybe I&#8217;m looking for doom.  I&#8217;m not as optimistic about GCC as you seem to be, but neither am I overly pessimistic.  On the plus side I think GCC is fairly open technically &#8212; everybody knows there are problems but there generally isn&#8217;t much resistance when someone codes up an improvement.  General cleanups are under-invested, but that seems to be an industry-wide phenomenon.</p>
	<p>On the minus side I would put certain developers&#8217; email styles, an occasionally unwieldy patch approval process (or, really, too few maintainer), and lack of transparency and change in the SC (though I liked what I heard from the SC at the summit, and this made the committee not seem quite as bad).
</p>
]]></content:encoded>
				</item>
	<item>
 		<title>Comment on Gcc vs. Users by: Ian Lance Taylor</title>
		<link>http://www.airs.com/blog/archives/81#comment-6127</link>
		<pubDate>Wed, 31 Oct 2007 03:40:57 +0000</pubDate>
		<guid>http://www.airs.com/blog/archives/81#comment-6127</guid>
					<description>It's hard to know for sure.  It's true that the cache miss latency is higher than the branch penalty.  But the difference is that it's a cache miss for a store, so all that latency will normally be hidden from the program--while the store is taking place, the program will continue to execute.  It would be an issue if it causes cache churn, or if the processor is out of memory slots.

You are certainly right that it's not an obvious win in all cases.</description>
		<content:encoded><![CDATA[	<p>It&#8217;s hard to know for sure.  It&#8217;s true that the cache miss latency is higher than the branch penalty.  But the difference is that it&#8217;s a cache miss for a store, so all that latency will normally be hidden from the program&#8211;while the store is taking place, the program will continue to execute.  It would be an issue if it causes cache churn, or if the processor is out of memory slots.</p>
	<p>You are certainly right that it&#8217;s not an obvious win in all cases.
</p>
]]></content:encoded>
				</item>
	<item>
 		<title>Comment on Gcc vs. Users by: fche</title>
		<link>http://www.airs.com/blog/archives/81#comment-6090</link>
		<pubDate>Tue, 30 Oct 2007 14:58:50 +0000</pubDate>
		<guid>http://www.airs.com/blog/archives/81#comment-6090</guid>
					<description>It seemed that the optimization under current controversy may have been misguided for reasons other than just breaking existing code.  It adds memory accesses that weren't there before, betting that this is a good trade against a branch/pipeline flush.  This bet however is highly suspect - cache miss latencies can exceed modern processor pipeline flush times, and can get even worse with SMP.   If there was anything other than a toy microbenchmark posted to justify this transform, I missed it.</description>
		<content:encoded><![CDATA[	<p>It seemed that the optimization under current controversy may have been misguided for reasons other than just breaking existing code.  It adds memory accesses that weren&#8217;t there before, betting that this is a good trade against a branch/pipeline flush.  This bet however is highly suspect - cache miss latencies can exceed modern processor pipeline flush times, and can get even worse with SMP.   If there was anything other than a toy microbenchmark posted to justify this transform, I missed it.
</p>
]]></content:encoded>
				</item>
	<item>
 		<title>Comment on Gcc vs. Users by: Ian Lance Taylor</title>
		<link>http://www.airs.com/blog/archives/81#comment-6087</link>
		<pubDate>Tue, 30 Oct 2007 14:24:15 +0000</pubDate>
		<guid>http://www.airs.com/blog/archives/81#comment-6087</guid>
					<description>4.x normally does better than 3.x.  That said, I have no idea about FFTW in particular.

Mark Mitchell isn't Project Leader, he's Release Manager.  There is no Project Leader.  That said, I think Mark probably could speak for gcc if he chose to assert himself.  However, he doesn't.  He prefers a more consensus oriented approach, which is the right way to operate within the gcc community but is less helpful when dealing with people who are outside that community.  Also Mark is very busy and tends to lag discussions by several days at best, so we see whole discussion firestorms before he has anything to say.</description>
		<content:encoded><![CDATA[	<p>4.x normally does better than 3.x.  That said, I have no idea about FFTW in particular.</p>
	<p>Mark Mitchell isn&#8217;t Project Leader, he&#8217;s Release Manager.  There is no Project Leader.  That said, I think Mark probably could speak for gcc if he chose to assert himself.  However, he doesn&#8217;t.  He prefers a more consensus oriented approach, which is the right way to operate within the gcc community but is less helpful when dealing with people who are outside that community.  Also Mark is very busy and tends to lag discussions by several days at best, so we see whole discussion firestorms before he has anything to say.
</p>
]]></content:encoded>
				</item>
	<item>
 		<title>Comment on Gcc vs. Users by: ncm</title>
		<link>http://www.airs.com/blog/archives/81#comment-6076</link>
		<pubDate>Tue, 30 Oct 2007 07:28:14 +0000</pubDate>
		<guid>http://www.airs.com/blog/archives/81#comment-6076</guid>
					<description>The situation with FFTW was rather simpler: they complained that each release since ... 2.7, I think, produced slower floating-point code in their innermost loops, on x86, than 2.7.  (As I recall, post-2.7 generated loops with unnecessary register spills.)  Last I heard was 3.3, but that's a lot of releases.  They were talking then about giving up and generating assembly code instead.  I don't know if they did, or whether 4.x (for any x) does any better.

Can't Mark Mitchell, as Project Leader, speak for Gcc?  If it has a future, I'm inclined to give him a lot of the credit for it.</description>
		<content:encoded><![CDATA[	<p>The situation with FFTW was rather simpler: they complained that each release since &#8230; 2.7, I think, produced slower floating-point code in their innermost loops, on x86, than 2.7.  (As I recall, post-2.7 generated loops with unnecessary register spills.)  Last I heard was 3.3, but that&#8217;s a lot of releases.  They were talking then about giving up and generating assembly code instead.  I don&#8217;t know if they did, or whether 4.x (for any x) does any better.</p>
	<p>Can&#8217;t Mark Mitchell, as Project Leader, speak for Gcc?  If it has a future, I&#8217;m inclined to give him a lot of the credit for it.
</p>
]]></content:encoded>
				</item>
</channel>
</rss>
