Page MenuHomePhabricator

[PM] Change the core design of the TTI analysis to use a polymorphic type erased interface and a single analysis pass rather than an extremely complex analysis group.
ClosedPublic

Authored by chandlerc on Jan 30 2015, 5:36 AM.

Details

Summary

The end result is that the TTI analysis can contain a type erased
implementation that supports the polymorphic TTI interface. We can build
one from a target-specific implementation or from a dummy one in the IR.

I've also factored all of the code into "mix-in"-able base classes,
including CRTP base classes to facilitate calling back up to the most
specialized form when delegating horizontally across the surface.

There are a number of reasons for this change, and this particular
design. The first and foremost reason is that an analysis group is
complete overkill, and the chaining delegation strategy was so opaque,
confusing, and high overhead that TTI was suffering greatly for it.
Several of the TTI functions had failed to be implemented in all places
because of the chaining-based delegation making there be no checking of
this. A few other functions were implemented with incorrect delegation.
The message to me was very clear working on this -- the delegation and
analysis group structure was too confusing to be useful here.

The other reason of course is that this is *much* more natural fit for
the new pass manager. This will lay the ground work for a type-erased
per-function info object that can look up the correct subtarget and even
cache it.

Yet another benefit is that this will significantly simplify the
interaction of the pass managers and the TargetMachine. See the future
work below.

There is still a lot more to be done here, but this was the huge chunk
that I couldn't really split things out of because this was the
interface change to TTI. I've tried to minimize all the other parts of
this. The follow up work should include:

  1. Improving the TargetMachine interface by having it directly return a TTI object. Because we have a non-pass object with value semantics and an internal type erasure mechanism, we can narrow the interface of the TargetMachine to *just* do what we need: build and return a TTI object that we can then insert into the pass pipeline.
  2. Make the TTI object be fully specialized for a particular function. This will include splitting off a minimal form of it which is sufficient for the inliner and the old pass manager.
  3. Add a new pass manager analysis which produces TTI objects from the target machine for each function.

Diff Detail

Repository
rL LLVM

Event Timeline

chandlerc updated this revision to Diff 19034.Jan 30 2015, 5:36 AM
chandlerc retitled this revision from to [PM] Change the core design of the TTI analysis to use a polymorphic type erased interface and a single analysis pass rather than an extremely complex analysis group..
chandlerc updated this object.
chandlerc edited the test plan for this revision. (Show Details)
chandlerc added reviewers: hfinkel, echristo.
chandlerc added a subscriber: Unknown Object (MLST).
echristo accepted this revision.Jan 30 2015, 5:03 PM
echristo edited edge metadata.

Looks pretty good to me. It might be nice for TTI to have a class design comment somewhere around it that gives some rough stubbed out directions for how specialization works, but in general no other comments than that.

This revision is now accepted and ready to land.Jan 30 2015, 5:03 PM
hfinkel accepted this revision.Jan 30 2015, 6:42 PM
hfinkel edited edge metadata.

We had a long discussion about this design on IRC, and I'm relatively happy with this now. Please go ahead.

include/llvm/Analysis/TargetTransformInfo.h
58 ↗(On Diff #19034)

I understand the comment, but I think it can be made less potentially-confusing. How about:

Construct a TTI object using a type implementing the Concept API below.
include/llvm/Analysis/TargetTransformInfoImpl.h
54 ↗(On Diff #19034)

Nevermind. ;)

This revision was automatically updated to reflect the committed changes.