mim::Scalarize Class Reference

Perform Scalarization (= Argument simplification). More...

#include <mim/phase/scalarize.h>

Inheritance diagram for mim::Scalarize:

Public Member Functions
	Scalarize (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)
Analysis *	analysis ()
const Analysis *	analysis () const
const Def *	lattice (const Def *old_def) const
	Returns the abstract value computed by the associated Analysis for the given old-world Def, or nullptr if no value is available.
const Def *	abstracted (const Def *old_def) const
	Returns lattice(old_def) if it differs from old_def (i.e. we learned something), otherwise nullptr.
virtual bool	analyze ()
	Runs the optional pre-analysis on RWPhase::old_world(), typically to a fixed point, before rewriting begins.
virtual void	rewrite_annex (flags_t, Sym, const Def *)
virtual void	rewrite_external (Def *)
bool	is_bootstrapping () const
	Returns whether we are currently bootstrapping (rewriting annexes).
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::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 ()
Log &	log () const
std::string_view	name () const
flags_t	annex () const
const 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 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 (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 (const Def *)
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
const Def *	rewrite_imm_Pi (const Pi *) final
const Def *	rewrite_mut_Lam (Lam *) final
const Def *	rewrite_imm_App (const App *) final

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
	Actual entry.
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

Perform Scalarization (= Argument simplification).

This means that, e.g.,

f := λ (x_1: [T_1, T_2], .., x_n: T_n).E

will be transformed to

f' := λ (y_1: T_1, y_2: T_2, .. y_n: T_n).E[x_1 \ (y_1, y_2); ..; x_n \ y_n]

The transformation is type-directed: the decision to flatten is made per continuation type (immutable Cn) - not per Lam. Every producer and consumer of such a type is reshaped in the same sweep: the Pi itself, all Lams of that type, and all Apps through it - no matter whether the callee is a mutable Lam, a Var (higher-order parameter), a branch tuple, or a value loaded back from memory. Hence, a Lam may escape (be stored, passed as argument) and still get its signature flattened.

A Pi is pinned (left untouched) if

• it is reachable from an annex (normalizers and backends rely on its exact shape),
• an Axm application's signature dictates it - what the Axm consumes and produces, plus a bare function argument's type (%autodiff.ad f) - except for subtrees that are merely substituted in via (type) arguments (T in %mem.store T), which stay flattenable,
• it occurs inside an interface Lam's signature (external, annex, or unset declaration) - only such a Lam's own top-level Pi stays flattenable (it may be shared with internal values; rewrite_mut_Lam() preserves the interface's top level by hand),
• it types a value inside a dependently-typed aggregate (a typed closure),
• an App connects a dom and an arg whose types are alpha-equivalent yet distinct defs, or
• one of its parameters is Extracted / Inserted via a non-constant index (splitting would only force the body to reassemble the tuple); this is tracked per parameter via a keep-bitmask.

The phase flattens one level of a Pi's (thresholded) domain per run. Because it is scheduled inside a fixed-point pipeline (compile.phases tt (...)), re-running it converges to a full flatten; each run that peels calls invalidate().

Flattening respects Flags::scalarize_threshold via the thresholded projection helpers (Def::num_tprojs, Pi::tdom, App::targ): a parameter is only expanded if its arity is below the threshold. It will not flatten mutable Sigmas or Arrays (their vars have no static arity).

Definition at line 46 of file scalarize.h.

Constructor & Destructor Documentation

Scalarize()

mim::Scalarize::Scalarize ( World & world, flags_t annex )

inline

Definition at line 81 of file scalarize.h.

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

Member Function Documentation

rewrite_imm_App()

const Def * mim::Scalarize::rewrite_imm_App ( const App * app )

finalprivate

Definition at line 275 of file scalarize.cpp.

References mim::World::app(), mim::App::callee(), mim::App::callee_type(), mim::RWPhase::is_bootstrapping(), mim::Def::isa_mut(), mim::isa_optimizable(), mim::RWPhase::new_world(), and mim::Rewriter::rewrite().

rewrite_imm_Pi()

const Def * mim::Scalarize::rewrite_imm_Pi ( const Pi * pi )

finalprivate

Definition at line 202 of file scalarize.cpp.

References mim::Pi::codom(), DLOG, mim::Phase::invalidate(), mim::RWPhase::is_bootstrapping(), mim::Pi::is_implicit(), mim::RWPhase::new_world(), mim::Rewriter::rewrite(), and mim::Vector().

rewrite_mut_Lam()

const Def * mim::Scalarize::rewrite_mut_Lam ( Lam * old )

finalprivate

Definition at line 225 of file scalarize.cpp.

References mim::Lam::body(), mim::Def::dbg(), DLOG, mim::Lam::filter(), mim::RWPhase::is_bootstrapping(), mim::isa_optimizable(), mim::Rewriter::map(), mim::RWPhase::new_world(), mim::Def::num_tvars(), mim::Rewriter::rewrite(), mim::Rewriter::rewrite_stub(), mim::Def::tvar(), mim::Def::type(), mim::Lam::type(), mim::Def::var(), and mim::Vector().

---

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

• include/mim/phase/scalarize.h
• src/mim/phase/scalarize.cpp