EduardoS (no.delete@this.spam.com) on November 19, 2012 11:41 am wrote:
> Wilco (Wilco.Dijkstra.delete@this.ntlworld.com) on November 19, 2012 9:31 am wrote:
> > That certainly helps, but you're still doing it multiple times on targets which may not have a lot of
> > resources. What is more efficient - every phone compiling every bit of software you download, or just
> > run a highly optimized binary which was compiled once with optimal settings on fast hardware?
>
> Compiling on target seens a reasonable compromise, allows for new hardware/new hardware features,
> cross binary optimizations, libraries updates and compiler updates as well, still, the compiling
> process will happen only during installation and updates, not at every run.

Install-time compilation would be far better than using a JIT indeed. But you still may not have enough memory/performance for link-time whole program optimization with profile feedback.

> > Cache locality is certainly important, but GC doesn't solve that - in reality it actually makes it worse.
>
> Well... Cache locality improvements with GC is measurable... No need to discuss.

Rubbish. GC is memory inefficient by definition, so claiming it is better for locality is just wishful thinking. Compacting GC's typically need 2-3 times more memory than a non-compacting GC, so are worse on average. Also the much higher memory allocation rate and resulting collections are bad for locality.

> > And that is before we consider the actual overhead of the
> > collection itself, often having to stop all threads
> > for long periods.
>
> No,
>
> 1) A background GC can run on another thread, specially usefull on not threaded software;

Concurrent GC has even larger overheads. It stops threads for shorter periods but stops them more often, so takes far longer overall. And then we haven't considered the far higher overheads on the generated code.

> 2) A full stop still the less resource hungry GC, but don't look at it without
> considering that, thanks to this GC allocations and deallocations are much faster
> and heap is compacted periodically, in the end, often it is a win.
>
> > Then there is the optimization overhead and extra tables causing code bloat.
>
> And C++ allocators waste space to avoid memory fragmentation... But doing so also hits locality.

No, no space is wasted, unlike GC which requires descriptors for every object.

> > For example arithmetic with overflow,
>
> By default, there is no overflow check, IIRC there is no way to even specify
> overflow check on Java, on C# it is optional but disabled by default.
>
> It is more a CPU design fault then language design fault, more often then not
> an overflow exception is more usefull than a mod 2^32 result, but few CPUs
> provides a fast way of overflow checks, MIPS being a notable exception.

Instructions that can trap are bad. That's why you see modern FPUs implement IEEE so you never need traps, not even for denormals.

> > array bounds checks,
>
> I was thinking about this one when you mentioned "other features", sometimes the
> compiler is able to optimize it away and when not, last part of the post.
>
> > null pointer checks, assuming
> > any pointer access may cause an exception,
>
> In x86 .Net this check is "cmp eax, [eax]" with the pointer in eax, on field access there
> is no check at all since it will raise an exception anyway in the case of a null pointer.
>
> Since null pointer checks are so cheap it is not clear wich optimizations are disabled
> by them, just put the check where it is needed to keep the correct order.

Since when is a memory access cheap? Every unnecesary instruction has a cost.

> > multithreading support etc etc.
>
> How exactly this lowers performance?

The barriers and other checks for concurrent GC or multithreaded access to fields are not exactly zero-cost and block many optimizations.

> > It's not like languages like Java or C# are new.
>
> New or not doesn't matter, B is older than C++ but didn't have as much effort as C++ on building compilers.

By your logic, C++ would be much slower than C as C++ is quite new. Clearly that's not the case - and the simple reason is that much of what goes on inside is unrelated to the source language or the target.

> What Java or C# doesn't have is a SpecCPU for wich compilers with ridiculous aggressive
> optimizations are written, just look at the too most popular compilers Visual C++ and
> GCC and compare to the ones used in SpecCPU (ICC, PGI, Open64 and SunStudio).
>
> Visual C++ in particular is very conservative, still, in some workloads
> (of course, other than SpecCPU) it outperforms the others.
>
> Oh, yes, there is SpecJBB, and JVM there are much more aggressive,
> try comparing they performance there to something else.

Not sure what your point is here. Yes VC++ does extremely well as it is optimized to do well on the millions of lines of code that people actually write (such as Windows and its apps) - as opposed to showing huge gains on a few small benchmarks.

> > It is significantly harder to write a good compiler
> > for them, and even then you can never get close to C++ performance. Many optimizations have to be
> > disabled or turned extremely conservative as an exception or GC may occur at any time.
>
> Strictly speaking, GC may occur during memory allocations, in C++ a exception may happen on a division,
> on pointer derreference and whatever the spec says "undefined behaviour",

Wrong. Exceptions can only happen explicitly with throw in C++.

managed languages are usually
> more strict about ordering, and it is not obvious weak ordering improves performance by that much.

The problem is not just the ordering, but the fact that more operations can cause exceptions. That alone creates a lot of overhead as you need to model flows from every possible exception to all possible exception handlers. Local variable values need to be preserved for example, severely limiting optimizations.

> > Obviously you could argue all the overhead is worth it as some of the features allow programmers to
> > write code faster. Whether that is a good or a bad thing is a different discussion altogether...
>
> And finally, back to array checks, yes, they reduce performance, and yes, it is a different discussion,
> but frankly, the performance reduction is pretty small and a lot of security bugs would be avoided by
> array bound checks, it is not something I would left behind even if performance was a big concern.

The performance cost is high if you happen to use arrays a lot. Even if you think it is worth it, and ignore the overhead as small enough, many of such costs add up to something quite large.

Wilco