 |
MimIR
MimIR is my Intermediate Representation
|
|
MimIR
MimIR is my Intermediate Representation
|
Bufferizes the low-level tensor axioms onto the shared buffer layer. More...
#include <mim/plug/tensor/phase/lower_to_mem.h>
Public Member Functions | |
| LowerToMem (World &world, flags_t annex) | |
| Public Member Functions inherited from mim::RWPhase | |
| RWPhase (World &world, std::string name, Analysis *analysis=nullptr) | |
| RWPhase (World &world, flags_t annex, Analysis *analysis=nullptr) | |
| void | rewrite_annex (flags_t, Sym, const Def *) override |
| void | rewrite_external (Def *) override |
| World & | world ()=delete |
| Hides both and forbids direct access. | |
| World & | old_world () |
| Get old Defs from here. | |
| World & | new_world () |
| Create new Defs into this. | |
| Public Member Functions inherited from mim::RWBase | |
| Analysis * | analysis () |
| const Analysis * | analysis () const |
| const Def * | lattice (const Def *def) const |
Returns the abstract value computed by the associated Analysis for def, or nullptr if no value is available. | |
| const Def * | abstracted (const Def *def) const |
Returns lattice(def) if it differs from def (i.e. we learned something), otherwise nullptr. | |
| virtual bool | analyze () |
| Runs the optional pre-analysis on Phase::world, typically to a fixed point, before rewriting begins. | |
| bool | is_bootstrapping () const |
| Returns whether we are currently bootstrapping (rewriting annexes). | |
| Public Member Functions inherited from mim::Phase | |
| Phase (World &world, std::string name) | |
| Phase (World &world, flags_t annex) | |
| virtual | ~Phase ()=default |
| virtual std::unique_ptr< Phase > | recreate () |
| Creates a new instance; needed by a fixed-point PhaseMan. | |
| virtual void | apply (const App *) |
| Invoked if your Phase has additional args. | |
| virtual void | apply (Phase &) |
| Dito, but invoked by Phase::recreate. | |
| virtual bool | redirects () const |
| If true, Phase::create uses take_resolved(). | |
| virtual std::unique_ptr< Phase > | take_resolved () |
| The Phase to use instead; nullptr means elide. | |
| World & | world () |
| Driver & | driver () |
| const fe::Log & | log () const |
| std::string_view | name () const |
| flags_t | annex () const |
| const fe::Vector< std::string > & | args () |
| Command-line arguments passed to this Phase's plugin via -X <plugin>:<arg>. | |
| bool | todo () const |
| void | invalidate (bool todo=true) |
| Signals that another round of fixed-point iteration is required, either as part of. | |
| virtual void | run () |
| Entry point and generates some debug output; invokes Phase::start. | |
| void | profile_count (std::string_view key, uint64_t n=1) |
Adds n to the custom fe::Profiler counter key of the current run; no-op unless profiling is enabled. | |
| Public Member Functions inherited from mim::Rewriter | |
| template<class D = Def> | |
| D * | curr_mut () const |
| Rewriter (std::unique_ptr< World > &&ptr) | |
| Rewriter (World &world) | |
| virtual | ~Rewriter () |
| void | reset (std::unique_ptr< World > &&ptr) |
| void | reset () |
| World & | world () |
| virtual void | push () |
| virtual void | pop () |
| virtual const Def * | map (const Def *old_def, const Def *new_def) |
| const Def * | map_root (const Def *old_def, const Def *new_def) |
| Like map() but records into the root map, so the entry outlives the current push()/pop() scope. | |
| const Def * | map (const Def *old_def, Defs new_defs) |
| const Def * | map (Defs old_defs, const Def *new_def) |
| const Def * | map (Defs old_defs, Defs new_defs) |
| virtual const Def * | lookup (const Def *old_def) |
| Lookup old_def by searching in reverse through the stack of maps. | |
| virtual const Def * | rewrite_imm (const Def *) |
| virtual const Def * | rewrite_mut (Def *) |
| virtual const Def * | rewrite_stub (Def *, Def *) |
| virtual DefVec | rewrite (Defs) |
| virtual const Def * | rewrite_imm_Seq (const Seq *seq) |
| virtual const Def * | rewrite_mut_Seq (Seq *seq) |
Private Member Functions | |
| void | start () override |
| Actual entry. | |
| const Def * | rewrite (const Def *) override |
| const Def * | rewrite_mut_Lam (Lam *) override |
| const Def * | rewrite_imm_App (const App *) override |
Additional Inherited Members | |
| Static Public Member Functions inherited from mim::Phase | |
| static std::unique_ptr< Phase > | create (const Flags2Phases &phases, const Def *def) |
| template<class A, class P> | |
| static void | hook (Flags2Phases &phases) |
| template<class P, class... Args> | |
| static void | run (Args &&... args) |
| Runs a single Phase. | |
| Protected Member Functions inherited from mim::RWPhase | |
| void | start () override |
| RWBase::start() and then swaps the two worlds. | |
| Protected Member Functions inherited from mim::RWBase | |
| virtual const Def * | rewrite_root (const Def *def) |
| Rewrites a root - i.e. an annex or an external. | |
| virtual void | finalize () |
| Run after all roots have been walked - but for an RWPhase still before the two worlds are swapped. | |
| RWBase (World &world, std::string name, Analysis *analysis) | |
| RWBase (World &world, flags_t annex, Analysis *analysis) | |
| RWBase (World &world, std::string name, Analysis *analysis, std::unique_ptr< World > &&new_world) | |
Rewrite the World of Phase::world into new_world. | |
| RWBase (World &world, flags_t annex, Analysis *analysis, std::unique_ptr< World > &&new_world) | |
| Protected Member Functions inherited from mim::Rewriter | |
| auto | enter (Def *new_mut) |
Updates curr_mut() to new_mut and restores it at the end of the scope. | |
| Protected Attributes inherited from mim::Phase | |
| std::string | name_ |
| Protected Attributes inherited from mim::Rewriter | |
| std::deque< Def2Def > | old2news_ |
Bufferizes the low-level tensor axioms onto the shared buffer layer.
get / set become buffer.read / buffer.write, generate becomes an allocating fill loop, map_reduce / broadcast / pad / concat / gather / scatter become their buffer-world btensor.* counterparts, and tensor array values «s; T» become buffer.Buf (r, s, T) handles. Afterwards buffer.lower_ptr lowers the buffer layer to mem.Ptr + mem.lea / mem.load / mem.store.
This phase is conversion-only: it rewrites types and operations but does not thread the mem.M memory monad itself. Emitted buffer operations consume a ⊥: mem.M 0 placeholder (or a short local chain rooted in a LowerToMem::fresh_mem continuation's var), and the SSA value dependencies keep them anchored and ordered. The mem.add_mem phase (mim::plug::mem::phase::AddMem), scheduled right after this one in the pipeline, then mem-extends all continuations and rewires every memory operand to the scheduler-placed current memory — handling returns, error continuations, join points, branch arms, and interleaving with a caller's own memory operations uniformly.
Which array types denote tensors (as opposed to index/shape arrays that share the Arr structure) is determined by role: a pre-pass collects the array operand/result types of the tensor operations, and only those types are rewritten to Buf — and only at function boundaries, never as a global type rewrite.
Definition at line 28 of file lower_to_mem.h.
Definition at line 30 of file lower_to_mem.h.
References mim::Phase::annex(), mim::RWPhase::RWPhase(), and mim::RWPhase::world().
|
overrideprivatevirtual |
Reimplemented from mim::Rewriter.
Definition at line 306 of file lower_to_mem.cpp.
References mim::RWBase::is_bootstrapping(), mim::Rewriter::rewrite(), and rewrite_imm_App().
Referenced by rewrite_imm_App().
|
overrideprivate |
Definition at line 395 of file lower_to_mem.cpp.
References mim::App::arg(), mim::App::callee(), mim::RWBase::is_bootstrapping(), mim::Axm::isa(), mim::Pi::isa_cn(), mim::Def::isa_mut(), mim::RWPhase::new_world(), rewrite(), and mim::Def::type().
Referenced by rewrite().
Definition at line 348 of file lower_to_mem.cpp.
References mim::RWBase::is_bootstrapping().
|
overrideprivatevirtual |
Actual entry.
Implements mim::Phase.
Definition at line 253 of file lower_to_mem.cpp.
References mim::RWPhase::start().
1.18.0