Re: [Gomp-discuss] Welcome!

[Biagio Lucini]

On Wed, 18 Dec 2002, [iso-8859-1] Pop Sébastian wrote:

> 
> OMP was designed to be a "language of directives".  The set of OMP
> directives serves as an interface between the programmer and the
> compiler.  The compiler can choose to follow these directions provided
> by the programmer, or just ignore them (as is the case of GCC today). 
> This is what Philippe Gerner calls in his PhD. thesis the contract
> between the programmer and the compiler. 
> 

Is this thesis available somewhere and does it contain useful
documentation for non expert like me on nodes, trees etc? I don't have a
background in Computer Science, I'm an humble physicist, so some more
basic documentation will be very welcome. Any suggestion?

> We just need some tree nodes in GENERIC tree representation for
> objects like threads (I'm not sure, but I think Java already uses them
> ...) 
> 

I'll buy that for the moment.

> > And, by the way, do you know a suitable candidate threading library that
> > we could use for threading the application?
> > 
> we could just use POSIX threads?
> 

That's what I was thinking of doing. Any other choice probably would be
unportable. The only thing that put me slightly off is that POSIX threads
are not exactly the easiest thread library on earth...


> Maybe this is only science fiction for the moment, but here is what I think 
> about all this...
> 
> OMP was designed in order to increase the interactivity between the
> programmer and the compiler.  Now what happens if we allow the
> programmer to deal directly with all the intermediate representations of
> the compiler? 
> 
> For example one would like to work at the function level, then it could
> study directly the call graph, and guide the compiler to optimize only
> some functions instead of applying the derecursivation on all the
> functions, we could allow the programmer to specifically optimize only
> those functions he expects.
> 
> We play the same game when we deal with parallelization directives: 
> instead of just writing directives in ASCII I think that the programmer
> would prefer the direct interaction with the compiler.  This constant 
> feedback 
> could be efficiently used by the compiler in order to propose more advanced 
> optimizations based on the informations the programmer is able to provide...
> (and what happens if the programmer provides false informations?...)
> 

It's a good idea, but how would be practicable in fact? In my experience,
many programmers don't know too much about optimisation and similar
things, and they are pretty happy with whatever the compiler does. Could
we use information given by a profiler as a feedback input?

Biagio