mim::plug::mem::phase::AddMem Class Reference

Threads the mem.M memory monad through the world: mem-extends continuations and rewires every memory operand to the current memory at that program point. More...

#include <mim/plug/mem/phase/add_mem.h>

Inheritance diagram for mim::plug::mem::phase::AddMem:

Public Member Functions
	AddMem (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.
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
bool	analyze () final
	Runs the optional pre-analysis on Phase::world, typically to a fixed point, before rewriting begins.
const Def *	rewrite (const Def *) override
const Def *	rewrite_mut_Lam (Lam *) override
const Def *	rewrite_imm_App (const App *) override
const Def *	rewrite_imm_Tuple (const Tuple *) override
const Def *	rewrite_imm_Pi (const Pi *) 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_

Detailed Description

Threads the mem.M memory monad through the world: mem-extends continuations and rewires every memory operand to the current memory at that program point.

It's primarily to be used as preparation for other phases that rely on all continuations having a mem. It also splices the ⊥ : mem.M 0 memory placeholders of freshly emitted memory operations into the global memory chain and resolves mem.fresh (a, k) requests by jumping to k with the current memory (see mim::plug::tensor::phase::LowerToMem, which emits both and schedules this phase right behind itself).

The rewrite is a plain RWPhase. Memory is a linear resource, so at any program point exactly one memory token is live - the current memory. We track it in AddMem::curr_mem_ while rewriting a continuation's body:

• it starts out as the continuation's (leading or grouped) mem parameter,
• a rewritten memory operation advances it to the operation's result mem, and
• every memory-typed operand is rewritten to the current memory.

Because the Rewriter visits operands before their users, the current memory naturally threads through the data-dependency order - no separate schedule is required. Independent ⊥/⊤ placeholder chains are thereby linearized into one chain in encounter order.

Three rules keep the rewrite type-correct in the presence of axiom-pinned ABIs:

• Only continuations (Pi::isa_cn) are mem-extended; direct-style functions (e.g. the affine index mappings passed to btensor.map_reduce_post) keep their signature.
• A pi whose leading parameter carries the memory grouped (the Fn [mem.M 0, To, ins] → … shape of a mem-threaded combiner) counts as already mem-threaded.
• Lams reachable from axm-app arguments are preserved untouched: axioms pin their arguments' ABI (e.g. the combiner slot of btensor.map_reduce_post), so mem-extending them would be ill-typed.

Definition at line 32 of file add_mem.h.

Constructor & Destructor Documentation

AddMem()

mim::plug::mem::phase::AddMem::AddMem ( World & world, flags_t annex )

inline

Definition at line 34 of file add_mem.h.

References mim::Phase::annex(), mim::RWPhase::RWPhase(), and mim::RWPhase::world().

Member Function Documentation

analyze()

bool mim::plug::mem::phase::AddMem::analyze ( )

finalprivatevirtual

Runs the optional pre-analysis on Phase::world, typically to a fixed point, before rewriting begins.

If analysis() is set, this is the natural place to iterate until Phase::todo() becomes false. If no Analysis is needed, simply return false.

Reimplemented from mim::RWBase.

Definition at line 11 of file add_mem.cpp.

References mim::App::axm(), mim::Axm::isa(), and mim::RWPhase::old_world().

rewrite()

const Def * mim::plug::mem::phase::AddMem::rewrite ( const Def * old_def )

overrideprivatevirtual

Reimplemented from mim::Rewriter.

Definition at line 42 of file add_mem.cpp.

References mim::RWBase::is_bootstrapping(), mim::Def::isa_imm(), mim::plug::mem::isa_mem(), mim::Def::isa_mut(), mim::Rewriter::rewrite(), rewrite_imm_Pi(), mim::Rewriter::rewrite_imm_Seq(), and rewrite_imm_Tuple().

Referenced by rewrite_imm_App(), rewrite_imm_Tuple(), and rewrite_mut_Lam().

rewrite_imm_App()

const Def * mim::plug::mem::phase::AddMem::rewrite_imm_App ( const App * app )

overrideprivate

Definition at line 135 of file add_mem.cpp.

References mim::App::arg(), mim::Phase::args(), mim::App::callee(), mim::RWBase::is_bootstrapping(), mim::Axm::isa(), mim::RWPhase::new_world(), rewrite(), and mim::Def::type().

rewrite_imm_Pi()

const Def * mim::plug::mem::phase::AddMem::rewrite_imm_Pi ( const Pi * pi )

overrideprivate

Definition at line 68 of file add_mem.cpp.

References mim::plug::mem::has_leading_mem(), mim::RWBase::is_bootstrapping(), mim::Pi::isa_cn(), mim::RWPhase::new_world(), and mim::VarRewriter::VarRewriter().

Referenced by rewrite().

rewrite_imm_Tuple()

const Def * mim::plug::mem::phase::AddMem::rewrite_imm_Tuple ( const Tuple * tuple )

overrideprivate

Definition at line 171 of file add_mem.cpp.

References mim::RWBase::is_bootstrapping(), mim::Pi::isa_cn(), mim::plug::mem::isa_mem(), mim::RWPhase::new_world(), and rewrite().

Referenced by rewrite().

rewrite_mut_Lam()

const Def * mim::plug::mem::phase::AddMem::rewrite_mut_Lam ( Lam * old_lam )

overrideprivate

Definition at line 105 of file add_mem.cpp.

References mim::Lam::body(), mim::Def::dbg_key(), mim::Lam::filter(), mim::RWBase::is_bootstrapping(), mim::Def::is_set(), mim::Rewriter::map(), mim::plug::mem::mem_var(), mim::World::mut_lam(), mim::RWPhase::new_world(), mim::Def::num_vars(), rewrite(), mim::Def::set(), mim::Lam::set(), mim::Lam::type(), and mim::Def::var().

---

The documentation for this class was generated from the following files:

• include/mim/plug/mem/phase/add_mem.h
• src/mim/plug/mem/phase/add_mem.cpp