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.

> 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.

> 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;

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.

> 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.

> 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.

> multithreading support etc etc.

How exactly this lowers performance?

> 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.

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.

> 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", managed languages are usually more strict about ordering, and it is not obvious weak ordering improves performance by that much.

> 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.