Re: C++ threads vs. Ada tasks - surprised

[Stephen Leake <stephen_leake@stephe-leake.org>]

Maciej Sobczak <see.my.homepage@gmail.com> writes:

> An important point that was discussed there was the potential gain
> from having tasking built-in the language. I have argued that there is
> none *functional* gain (there is an obvious gain in readability,
> though), or rather that all compiler tricks can be performed with
> standard API as well.

This makes sense, except that with a higher-level tasking model, there
is more room for optimization of simple cases.

> To be frank: I have expected to see the C++ version being a hell lot
> of faster, as the Ada tasking model is conceptually much more complex
> and therefore I have expected tons of overhead there.

I would not have expected much speed difference; Ada tasks map quite
nicely to Posix threads.

> My expectations were wrong, as the Ada version proved to be ~2x
> faster on my machine (with GNAT 4.4.0 and g++ 4.4.0, taken from the
> same package, both versions compiled with -O2).

Interesting!

Getting this benchmark on the shootout page would be nice :).

> After this exercise I have no choice (frankly) than to admit that
> built-in threading support is better *also* in terms of performance.
> Damned benchmarks... ;-)

You could explain this by saying the Ada implementation took advantage
of what it knows about tasking, while the C++ implementation did _not_
take advantage of any knowledge about the Posix tasking API.

So the challenge is to add that knowledge to g++, and see if it
actually helps.

I guess the issue is "what compiler/run-time tricks were used to make
the Ada code faster than the simple calls to Posix"?

You could try using -gnatD to see what lower-level constructs GNAT
used.

And there's some sort of "trace" facility in Linux, that reports calls
to "system" routines; that might be useful (I've never used it).

-- 
-- Stephe