Re: Ada and OpenMP

["Peter C. Chapin" <PChapin@vtc.vsc.edu>]

On 03/07/2013 06:42 PM, Randy Brukardt wrote:

> Isn't OpenMP aimed at SIMD-type machines (as in video processors), as
> opposed to generalized cores as in typical Intel and ARM designs?
> Fine-grained parallelism doesn't make much sense on the latter, because
> cache coherence and core scheduling issues will eat up gains in almost all
> circumstances. Ada tasks are a much better model.

Well, I used OpenMP for a program targeting x64 architectures and it 
worked well in my case. It was easy to use: my program became 8x faster 
by the addition of a single line of source text. It even computed the 
right answer. My program was very well suited to the OpenMP model of 
computation, however, so I wouldn't expect such a dramatic result in all 
cases of course.

> Well, this doesn't make much sense. If the pragma doesn't change the
> semantics of the loop, then its not necessary at all (the compiler can and
> ought to do the optimization when it makes sense, possibly under the control
> of global flags). Programmers are lousy at determining where and how the
> best of use of machine resources can be made.

I only used the pragma above to follow the mindset of OpenMP under C. I 
agree it might not be the best way to do it in Ada.

I'm a little uncertain, though, about how well the compiler can be 
expected to find this sort of parallelization... at least with current 
technology. The compiler I was using for the program above, and it 
wasn't an ancient one, certainly had no idea how to do such things on 
its own.

In a high performance application nested loops are common and often the 
body of a loop calls a subprogram implemented in a library that itself 
has loops. I don't want all of these nested loops parallelized because 
that would create huge overheads. Yet without detailed semantic 
information about what the library subprograms do, I'm not sure how the 
compiler can know it's safe to parallelize the top level loop.

I'm not an expert in writing parallelizing compilers for sure, but it 
seemed to me, when I was experimenting with OpenMP, that it did a nice 
job of taking care of the grunt work while still allow me to apply my 
broad knowledge of the application to find good places to parallelize.

I certainly could have written my earlier program with tasks. In fact I 
had a version that used threads before I tried OpenMP. It worked but it 
was ugly and a bit flaky. Doing the job with one line was certainly a 
lot nicer and proved to be more reliable (and faster running too, in my 
case).

Peter