
Autopiper: automatic pipeline synthesis - luu
https://github.com/google/autopiper
======
cfallin
Hey cool, someone pointed me here -- surprised to find my toy side-project on
HN! I'm not actively hacking on autopiper at the moment (busy with other
things) but I still believe the semantics/ideas are sound and I'd love to find
more time for it someday. In its current state it's more of a proof-of-
concept.

I think it might do better as a DSL that lowers to the pipeline representation
directly (embedded in, say, Haskell or Scala), rather than inferring intent
from a CFG -- benefit of hindsight...

~~~
FullyFunctional
This is very cool. I have been/am toying with very same ideas, but using a
Lava variant, all in the context of Reduceron. I'm also planning to redo my
RISC-V implementation as a working example.

Silvia Muller in "Computer Architecture: Complexity and Correctness" describes
work on auto-pipelining. Are you basing your work on this or something else?

~~~
cfallin
Interesting! I saw Lava briefly and understood it as basically a DSL to
describe logic; additional abstractions to build pipelines on top of that
would be very cool. Looking forward to seeing what comes out of your work!

And yup, there's been a lot of past work on auto-pipelining, but my
understanding of what's been done before is that it handles splitting logic
into stages, but doesn't necessarily encapsulate more complex patterns -- e.g.
no one has built a tool that understands stall logic or bypass networks or
clears/restarts in a pipeline and can synthesize those patterns flexibly.

So you could see autopiper's main contribution as the "lowering" of a
conventional SSA-based IR into pipelined logic, along with the primitives
necessary to describe the actual semantic intent behind design patterns
(ask/provide for bypass, killyounger and CFG backedges for pipeline restarts),
and the insight that macros can use those primitives to build things like
speculation.

If you know of any other past work I'd be really interested to see it!

