gomp-discuss
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: [Gomp-discuss] Somethings to think about ....


From: Lars Segerlund
Subject: Re: [Gomp-discuss] Somethings to think about ....
Date: Tue, 11 Mar 2003 12:28:58 +0100
User-agent: Mozilla/5.0 (X11; U; Linux i586; en-US; rv:1.2.1) Gecko/20021226 Debian/1.2.1-9


I do think we need to have a discussion about this since it impacts where we should start, and if I'm not totally wrong the concensus seem's to be that we need to start making the GENERIC level concurrency aware ?

Now when it comes to CIL, if we have made generic 'concurrency aware' enough, then it should be no problem of handling CIL, if we can't handle CIL in GENERIC then it's not concurrency aware ( or not much ). Here I think Steven has a good suggestion of making GENERIC able to represent everything in CIL.

Now we have had a lot of frontend discussions, and is there a frontend that emits CIL ? This would make it a bit easier for us to try out our middle end with a CIL -> GENERIC translation. ( Please, I don't know enough about this, this might be a good or bad idea ).

Then when it comes to the rest of gcc, I don't think there is anything that stops us from trying to improve things as we go from GENERIC and downwards.

The main thing is really what might algorithms need in order to be concurrency aware and efficient !

If we pick GENERIC as a starting point then we need the docs on it, and then need to document the extensions we need. When we have a specification of this we can start working on both end's, front and backend.

I think it's a sound strategy to start of with GENERIC, is this something everyone agrees on ?

 / Lars Segerlund.

Steven Bosscher wrote:
On Tue 11-03-2003  10:42  Lars Segerlund took OT to the next level:

In the discussion on the gcc mailing list a while ago someone suggested that the tree structures should be restructured in a way as to prevent duplication of information when lowering, ( thus lowering would mainly consist of adding nodes to the tree and perhaps some infor mation), and this would give a representation which could keep the higher level constructs all the way to the RTL ( since the RTL could be attached to the tree ).


[ OT:  Frankly this is one of the biggest problems in GCC: It
  does not have an IR that can be "lowered" in the traditional
  meaning of the word.  The only "real" lowering we do is
  GENERIC->GIMPLE, everything else is a complete rewrite.  When
  GCC lowers from trees to RTL, it basically duplicates the
  whole tree in a completely new representation (adding cruft
  and magic all over in the process). ]

[ OT^2: Diego, do you plan to lower GIMPLE even further?
  The closer you'd bring it to RTL, the easier (hence
  faster, less bloated) the tree->RTL expanders could be... ]

OK, now lets try to get back ON topic...  What does this discussion mean
for our project?

Seb. said that CIL is concurrency-aware.  Maybe somebody can explain a
bit how it represents concurrency, e.g.:  Which constructs does it have
to support concurrency, and how does it handle data in those constructs
(i.e. what is thread private, what is a semaphore, etc.).  Is it enough
to support everything we need for OpenMP?  And, is it reasonably small?

If so, we could model our GENERIC concurrency-awareness tree
representation to what CIL does.  We could then define a superset of
these trees that can represent OpenMP pragmas in the parser, and lower
the superset to the stuff we'd have in GENERIC in the pass than
translates the C/C++ parse tree to GENERIC.

Greetz
Steevn




_______________________________________________
Gomp-discuss mailing list
address@hidden
http://mail.nongnu.org/mailman/listinfo/gomp-discuss






reply via email to

[Prev in Thread] Current Thread [Next in Thread]