On Tue, 11 Sep 2012 01:21:59 +0530 Sanjoy Das <sanjoy at playingwithpointers.com> wrote: Sanjoy, Thanks for working on this! Comments below...> Hi all, > > I made some progress on implementing Hal's proposal [1] for > implementing OpenMP support in LLVM. The patch I've attached just > barely compiles, but I'd like to get some input on the design early on > to prevent trouble later. I'd especially like some input on the > following points: > > * Metadata is never mutated or dropped > > I think it is better to have an analysis pass that simply provides a > consistent "view" of the current !parallel nodes instead of one that > mutates the IR in order to make it consistent. By addRequired<> ing > it (called ParallizationMetadata currently) in the lowering pass and > only indirectly accessing the metadata through the analysis pass, we > are assured that we don't parallelize regions with inconsistent > metadata.My rationale for proposing the self-consistent metadata solution was that it seemed to be the safest option. If we simply insist that all relevant passes use the ParallizationMetadata pass, without any verification, then we could end up with parallelization-unaware passes silently miscompiling code when parallelization is enabled. Do you have a way of avoiding that?> > * No information is optional > > It simplifies the implementation greatly if we change the spec to > assume this. I don't think this restriction shifts any significant > complexity to the frontends.Okay.> > * Loops don't have lists of special handling regions > > Since loops are always nested inside parallel regions, can't we > maintain this list in the parent region itself?I'm not sure. We do need to make sure, for example, that an 'ordered' region stays properly nested within its parent loop.> > * Tripping assertions vs. silently ignoring metadata > > I'm not very clear on when it is "right" to silently ignore metadata > and when to assert. Right now I assert only when a !parallel MDNode > has an incorrect number of children (this is one thing simplified by > making all fields compulsory). The verifier probably needs to know > about this constraint, something I haven't addressed yet. Should our > assertions be stricter or must we not assert at all?We should assert when an individual metadata entry is malformed; we should drop non-self-consistent sets of metadata entries (as these might have resulted from the actions of non-parallelization-aware transformation passes. -Hal> > (The code is also up on Github [2]). > > Thanks! > > [1] http://lists.cs.uiuc.edu/pipermail/llvmdev/2012-August/052472.html > [2] https://github.com/sanjoy/llvm/tree/parallel-md > > > -- > Sanjoy Das > http://playingwithpointers.com-- Hal Finkel Postdoctoral Appointee Leadership Computing Facility Argonne National Laboratory
Hi Hal,> My rationale for proposing the self-consistent metadata solution was > that it seemed to be the safest option. If we simply insist that all > relevant passes use the ParallizationMetadata pass, without any > verification, then we could end up with parallelization-unaware passes > silently miscompiling code when parallelization is enabled. Do you have > a way of avoiding that?I'm still not very clear about this. Either a pass understands (and looks at) the parallelization metadata or it doesn't. In case it doesn't it doesn't matter what the metadata looks like anyway. In case it does, we have the ParallelizationMetadata pass to present a consistent view of the metadata; how does it matter how the metadata actually looks like? I think it will be helpful if you could illustrate your point with an example. To be clear, I'm not saying that dropping metadata is unreasonable; but am trying to figure out what the core issues are. :)> I'm not sure. We do need to make sure, for example, that an 'ordered' > region stays properly nested within its parent loop.The ordered region mentions the parent loop anyway. Since the grandparent region refs the ordered region, we can ensure that the ordered region isn't dropped (leading to races).> We should assert when an individual metadata entry is malformed; we > should drop non-self-consistent sets of metadata entries (as these > might have resulted from the actions of non-parallelization-aware > transformation passes.Makes sense. Thanks! -- Sanjoy Das http://playingwithpointers.com
On Thu, 13 Sep 2012 09:01:18 +0530 Sanjoy Das <sanjoy at playingwithpointers.com> wrote:> Hi Hal, > > > My rationale for proposing the self-consistent metadata solution was > > that it seemed to be the safest option. If we simply insist that all > > relevant passes use the ParallizationMetadata pass, without any > > verification, then we could end up with parallelization-unaware > > passes silently miscompiling code when parallelization is enabled. > > Do you have a way of avoiding that? > > I'm still not very clear about this. Either a pass understands (and > looks at) the parallelization metadata or it doesn't. In case it > doesn't it doesn't matter what the metadata looks like anyway. In > case it does, we have the ParallelizationMetadata pass to present a > consistent view of the metadata; how does it matter how the metadata > actually looks like? I think it will be helpful if you could > illustrate your point with an example.My largest concern is, for example, having a parallel region with a serial subregion, and having some transformation pass do something which drops the metadata marking the serial subregion while leaving the parent parallel region. This would lead to miscompiled code. As transformation passes are allowed to drop metadata arbitrarily, and people have out-of-tree passes that do IPO (which we can't fix ourselves), I think that we need to assume that any combination of the metadata can be dropped at any time. An alternative approach, which you seem to be proposing, is that the parallelization reads the metadata up front (and then drops it all). If a pass does not preserve that analysis, then it will be invalidated, and the parallelization will be lost. This, indeed, might be a better approach, but would at least require touching a lot more code (if nothing else, we'd need to audit and then add the analysis preservation calls to a lot of otherwise-unrelated code). -Hal> > To be clear, I'm not saying that dropping metadata is unreasonable; > but am trying to figure out what the core issues are. :) > > > I'm not sure. We do need to make sure, for example, that an > > 'ordered' region stays properly nested within its parent loop. > > The ordered region mentions the parent loop anyway. Since the > grandparent region refs the ordered region, we can ensure that the > ordered region isn't dropped (leading to races). > > > We should assert when an individual metadata entry is malformed; we > > should drop non-self-consistent sets of metadata entries (as these > > might have resulted from the actions of non-parallelization-aware > > transformation passes. > > Makes sense. > > Thanks!-- Hal Finkel Postdoctoral Appointee Leadership Computing Facility Argonne National Laboratory