from __future__ import annotations
import collections
import functools
import numbers
import typing
import weakref
from collections.abc import Mapping
from typing import Any, Literal
import numpy as np
from immutabledict import immutabledict as idict
from mpi4py import MPI
import pyop3.axis_tree
import pyop3.buffer
import pyop3.config
import pyop3.exceptions
import pyop3.expr
import pyop3.index_tree
import pyop3.visitors
from pyop3 import utils
from pyop3.axis_tree.tree import (
UNIT_AXIS_TREE,
Axis,
AxisTree,
merge_axis_trees,
)
from pyop3.cache import memory_cache
from pyop3.collections import OrderedFrozenSet, OrderedSet
from pyop3.dtypes import IntType
from pyop3.expr.base import ExpressionT, conditional, loopified_shape
from pyop3.expr.tensor import Dat, Mat, Scalar
from pyop3.expr.tensor.base import (
OutOfPlaceCallableTensorTransform,
ReshapeTensorTransform,
)
from pyop3.index_tree.tree import (
LoopIndex,
Slice,
)
from pyop3.insn.base import ArrayAccessType, loop_
# TODO: just namespace these
from pyop3.labeled_tree import is_subpath
from pyop3.node import NodeCollector, NodeTransformer, NodeVisitor, postorder
from pyop3.expr.visitors.evaluate_arraywise import evaluate_arraywise # noqa: F401
if typing.TYPE_CHECKING:
from pyop3.types import *
AxisVarMapT = Mapping[AxisLabelT, int]
[docs]
class ExpressionVisitor(NodeVisitor):
[docs]
@functools.singledispatchmethod
def children(self, node, /):
return super().children(node)
@children.register(numbers.Number)
def _(self, node, /):
return idict()
# TODO: use overloadedexpressionevaluator
[docs]
def evaluate(expr: ExpressionT, *, axis_vars: AxisVarMapT | None = None, loop_indices=None, name_vars=idict(), allow_missing: bool = False) -> Any:
if axis_vars is None:
axis_vars = {}
if loop_indices is None:
loop_indices = {}
return _evaluate(expr, axis_vars=axis_vars, loop_indices=loop_indices, name_vars=name_vars, allow_missing=allow_missing)
@functools.singledispatch
def _evaluate(obj: Any, /, **kwargs) -> Any:
raise TypeError(f"No handler defined for {type(obj).__name__}")
@_evaluate.register(numbers.Number)
@_evaluate.register(bool)
@_evaluate.register(np.bool)
def _(num, /, **kwargs) -> Any:
return num
@_evaluate.register
def _(var: pyop3.expr.NameVar, /, *, name_vars: Mapping, allow_missing: bool, **kwargs) -> Any:
try:
return name_vars[var.name]
except KeyError:
if allow_missing:
return var
else:
raise pyop3.exceptions.MissingVariableException(f"'{var.name}' not found in 'name_vars'")
@_evaluate.register(pyop3.expr.AxisVar)
def _(axis_var: pyop3.expr.AxisVar, /, *, axis_vars: AxisVarMapT, allow_missing: bool, **kwargs) -> Any:
try:
return axis_vars[axis_var.axis.label]
except KeyError:
if allow_missing:
return axis_var
else:
raise pyop3.exceptions.MissingVariableException(f"'{axis_var.axis.label}' not found in 'axis_vars'")
@_evaluate.register(pyop3.expr.LoopIndexVar)
def _(loop_var: pyop3.expr.LoopIndexVar, /, *, loop_indices, allow_missing: bool, **kwargs) -> Any:
try:
return loop_indices[loop_var.loop_index.id][loop_var.axis.label]
except KeyError:
if allow_missing:
return loop_var
else:
raise pyop3.exceptions.MissingVariableException(f"'({loop_var.loop_index.id}, {loop_var.axis.label})' not found in 'loop_indices'")
@_evaluate.register
def _(expr: pyop3.expr.Add, /, **kwargs) -> Any:
return _evaluate(expr.a, **kwargs) + _evaluate(expr.b, **kwargs)
@_evaluate.register
def _(sub: pyop3.expr.Sub, /, **kwargs) -> Any:
return _evaluate(sub.a, **kwargs) - _evaluate(sub.b, **kwargs)
@_evaluate.register
def _(mul: pyop3.expr.Mul, /, **kwargs) -> Any:
return _evaluate(mul.a, **kwargs) * _evaluate(mul.b, **kwargs)
@_evaluate.register
def _(neg: pyop3.expr.Neg, /, **kwargs) -> Any:
return -_evaluate(neg.a, **kwargs)
@_evaluate.register
def _(floordiv: pyop3.expr.FloorDiv, /, **kwargs) -> Any:
return _evaluate(floordiv.a, **kwargs) // _evaluate(floordiv.b, **kwargs)
@_evaluate.register
def _(or_: pyop3.expr.Or, /, **kwargs) -> Any:
return _evaluate(or_.a, **kwargs) or _evaluate(or_.b, **kwargs)
@_evaluate.register
def _(lt: pyop3.expr.LessThan, /, **kwargs) -> Any:
return _evaluate(lt.a, **kwargs) < _evaluate(lt.b, **kwargs)
@_evaluate.register
def _(gt: pyop3.expr.GreaterThan, /, **kwargs) -> Any:
return _evaluate(gt.a, **kwargs) > _evaluate(gt.b, **kwargs)
@_evaluate.register
def _(le: pyop3.expr.LessThanOrEqual, /, **kwargs) -> Any:
return _evaluate(le.a, **kwargs) <= _evaluate(le.b, **kwargs)
@_evaluate.register
def _(ge: pyop3.expr.GreaterThanOrEqual, /, **kwargs) -> Any:
return _evaluate(ge.a, **kwargs) >= _evaluate(ge.b, **kwargs)
@_evaluate.register
def _(cond: pyop3.expr.Conditional, /, **kwargs) -> Any:
if _evaluate(cond.predicate, **kwargs):
return _evaluate(cond.if_true, **kwargs)
else:
return _evaluate(cond.if_false, **kwargs)
@_evaluate.register(pyop3.expr.Dat)
def _(dat: pyop3.expr.Dat, /, **kwargs) -> Any:
# if not linear I don't think we know what to do
return _evaluate(dat.concretize(linear=True), **kwargs)
@_evaluate.register(pyop3.expr.ScalarBufferExpression)
def _(scalar: pyop3.expr.ScalarBufferExpression, /, **kwargs) -> numbers.Number:
return scalar.value
@_evaluate.register
def _(dat_expr: pyop3.expr.LinearDatBufferExpression, /, **kwargs) -> Any:
offset = _evaluate(dat_expr.layout, **kwargs)
if isinstance(offset, numbers.Integral):
return dat_expr.buffer.data_ro[offset]
else:
return dat_expr.record_new(layout=offset)
[docs]
@functools.singledispatch
def collect_loop_index_vars(obj: Any, /) -> OrderedSet:
raise TypeError(f"No handler defined for {type(obj).__name__}")
@collect_loop_index_vars.register(pyop3.expr.LoopIndexVar)
def _(loop_var: pyop3.expr.LoopIndexVar):
return OrderedSet({loop_var})
@collect_loop_index_vars.register(numbers.Number)
@collect_loop_index_vars.register(pyop3.expr.AxisVar)
@collect_loop_index_vars.register(pyop3.expr.NaN)
@collect_loop_index_vars.register(pyop3.expr.ScalarBufferExpression)
@collect_loop_index_vars.register(pyop3.expr.Scalar)
def _(var):
return OrderedSet()
@collect_loop_index_vars.register(pyop3.expr.Operator)
def _(op: pyop3.expr.BinaryOperator):
return OrderedSet().union(*map(collect_loop_index_vars, op.operands))
@collect_loop_index_vars.register(pyop3.expr.Dat)
def _(dat: pyop3.expr.Dat, /) -> OrderedSet:
loop_indices = OrderedSet()
if dat.transform:
loop_indices |= collect_loop_index_vars(dat.transform)
for axis_tree in pyop3.axis_tree.iter_axis_trees(dat.axes):
for leaf_layout in axis_tree.leaf_subst_layouts.values():
loop_indices |= collect_loop_index_vars(leaf_layout)
return loop_indices
@collect_loop_index_vars.register(pyop3.expr.CompositeDat)
def _(dat: pyop3.expr.CompositeDat, /) -> OrderedSet:
return utils.reduce("|", map(collect_loop_index_vars, dat.exprs.values()), OrderedSet())
@collect_loop_index_vars.register(pyop3.expr.LinearDatBufferExpression)
def _(expr: pyop3.expr.LinearDatBufferExpression, /) -> OrderedSet:
return collect_loop_index_vars(expr.layout)
@collect_loop_index_vars.register(pyop3.expr.Mat)
def _(mat: pyop3.expr.Mat, /) -> OrderedSet:
loop_indices = OrderedSet()
if mat.transform:
loop_indices |= collect_loop_index_vars(mat.transform)
for axes in [mat.row_axes, mat.column_axes]:
for axis_tree in pyop3.axis_tree.iter_axis_trees(axes):
for leaf_layout in axis_tree.leaf_subst_layouts.values():
loop_indices |= collect_loop_index_vars(leaf_layout)
return loop_indices
@collect_loop_index_vars.register
def _(reshape: pyop3.expr.ReshapeTensorTransform, /) -> OrderedSet:
loop_indices = OrderedSet()
for axis_tree_like in reshape.axis_trees:
for axis_tree in pyop3.axis_tree.iter_axis_trees(axis_tree_like):
for leaf_layout in axis_tree.leaf_subst_layouts.values():
loop_indices |= collect_loop_index_vars(leaf_layout)
if reshape.prev:
loop_indices |= collect_loop_index_vars(reshape.prev)
return loop_indices
[docs]
@functools.singledispatch
def restrict_to_context(obj: Any, /, loop_context):
raise TypeError(f"No handler defined for {type(obj).__name__}")
@restrict_to_context.register(numbers.Number)
@restrict_to_context.register(pyop3.expr.AxisVar)
@restrict_to_context.register(pyop3.expr.LoopIndexVar)
@restrict_to_context.register(pyop3.expr.BufferExpression)
@restrict_to_context.register(pyop3.expr.NaN)
def _(var: Any, /, loop_context) -> Any:
return var
@restrict_to_context.register
def _(op: pyop3.expr.UnaryOperator, /, loop_context):
return type(op)(restrict_to_context(op.a, loop_context))
@restrict_to_context.register
def _(op: pyop3.expr.BinaryOperator, /, loop_context):
return type(op)(restrict_to_context(op.a, loop_context), restrict_to_context(op.b, loop_context))
@restrict_to_context.register
def _(op: pyop3.expr.Conditional, /, loop_context):
return type(op)(restrict_to_context(op.a, loop_context), restrict_to_context(op.b, loop_context), restrict_to_context(op.c, loop_context))
@restrict_to_context.register(pyop3.expr.Tensor)
@restrict_to_context.register(pyop3.expr.AggregateDat) # should be a Tensor
def _(array: pyop3.expr.Tensor, /, loop_context):
return array.with_context(loop_context)
[docs]
def replace_terminals(obj: Any, /, replace_map, *, assert_modified: bool = False) -> ExpressionT:
new_obj = _replace_terminals(obj, replace_map)
if assert_modified and new_obj == obj:
raise pyop3.exceptions.ExpressionUnchangedException
return new_obj
@functools.singledispatch
def _replace_terminals(obj: Any, /, replace_map) -> ExpressionT:
raise TypeError(f"No handler defined for {type(obj).__name__}")
@_replace_terminals.register(pyop3.expr.AxisVar)
def _(axis_var: pyop3.expr.AxisVar, /, replace_map) -> ExpressionT:
return replace_map.get(axis_var.axis.label, axis_var)
@_replace_terminals.register(bool)
@_replace_terminals.register(numbers.Number)
@_replace_terminals.register(np.bool)
@_replace_terminals.register(pyop3.expr.NaN)
@_replace_terminals.register(pyop3.expr.LoopIndexVar)
def _(var: ExpressionT, /, replace_map) -> ExpressionT:
return var
# I don't like doing this.
@_replace_terminals.register(pyop3.expr.Dat)
def _(dat: pyop3.expr.Dat, /, replace_map):
return _replace_terminals(dat.concretize(), replace_map)
@_replace_terminals.register(pyop3.expr.ScalarBufferExpression)
def _(expr: pyop3.expr.ScalarBufferExpression, /, replace_map):
return replace_map.get(expr, expr)
@_replace_terminals.register(pyop3.expr.LinearDatBufferExpression)
def _(expr: pyop3.expr.LinearDatBufferExpression, /, replace_map) -> pyop3.expr.LinearDatBufferExpression:
new_layout = _replace_terminals(expr.layout, replace_map)
return expr.record_new(layout=new_layout)
@_replace_terminals.register(pyop3.expr.BinaryOperator)
def _(op: pyop3.expr.BinaryOperator, /, replace_map) -> pyop3.expr.BinaryOperator:
return type(op)(_replace_terminals(op.a, replace_map), _replace_terminals(op.b, replace_map))
@_replace_terminals.register
def _(cond: pyop3.expr.Conditional, /, replace_map) -> pyop3.expr.Conditional:
return type(cond)(_replace_terminals(cond.predicate, replace_map), _replace_terminals(cond.if_true, replace_map), _replace_terminals(cond.if_false, replace_map))
@_replace_terminals.register
def _(neg: pyop3.expr.Neg, /, replace_map) -> pyop3.expr.Neg:
return type(neg)(_replace_terminals(neg.a, replace_map))
[docs]
@functools.singledispatch
def collect_axis_vars(obj: Any, /) -> OrderedSet:
raise TypeError(f"No handler defined for {type(obj).__name__}")
@collect_axis_vars.register
def _(op: pyop3.expr.Operator):
return utils.reduce("|", map(collect_axis_vars, op.operands))
@collect_axis_vars.register(numbers.Number)
@collect_axis_vars.register(pyop3.expr.LoopIndexVar)
@collect_axis_vars.register(pyop3.expr.NaN)
def _(var):
return OrderedSet()
@collect_axis_vars.register(pyop3.expr.AxisVar)
def _(var):
return OrderedSet([var])
@collect_axis_vars.register(pyop3.expr.LinearDatBufferExpression)
def _(dat: pyop3.expr.LinearDatBufferExpression, /) -> OrderedSet:
return collect_axis_vars(dat.layout)
@collect_axis_vars.register(pyop3.expr.NonlinearDatBufferExpression)
def _(dat: pyop3.expr.NonlinearDatBufferExpression, /) -> OrderedSet:
result = OrderedSet()
for layout_expr in dat.layouts.values():
result |= collect_axis_vars(layout_expr)
return result
[docs]
def materialize_composite_dat(
composite_dat: pyop3.expr.CompositeDat,
comm: MPI.Comm,
linear: bool,
) -> pyop3.expr.BufferExpression:
import pyop3.visitors
# For maximum cache reuse we relabel the expression on the way in and
# apply the inverse relabeling on the way out
relabeler = pyop3.visitors.Relabeler()
relabeled_composite_dat = relabeler(composite_dat)
materialized = _materialize_composite_dat_cached(relabeled_composite_dat, comm, linear)
# Set allow_missing to true because certain elements of the layout expressions
# are not entirely replaced on the way out. This is because of the (slightly)
# permissive implementation of AxisVar.__hash__. The differences between the
# axis vars are cosmetic and do not affect anything, there are just certain
# deeply nested attributes that will raise key errors otherwise.
# This issue was specifically encountered with restricted function spaces, where
# one gets axis vars wrapping axes with tabulated region sizes.
return pyop3.visitors.relabel(materialized, relabeler.inverse_relabel_map, allow_missing=True)
@memory_cache(heavy=True)
@pyop3.mpi.collective
def _materialize_composite_dat_cached(
composite_dat: pyop3.expr.CompositeDat,
comm: MPI.Comm, # needed now?
linear,
) -> pyop3.expr.NonlinearDatBufferExpression:
import pyop3.visitors
big_tree, loop_var_replace_map = loopified_shape(composite_dat)
# step 2: assign
assignee = Dat.empty(big_tree, dtype=IntType)
loop_slices = []
for axis_var in loop_var_replace_map.values():
axis = axis_var.axis
loop_slices.append(Slice(axis.label, utils.atom(axis.component.label)))
for leaf_path in composite_dat.axis_tree.leaf_paths:
leaf_expr = composite_dat.exprs[leaf_path]
leaf_expr = pyop3.visitors.replace(leaf_expr, loop_var_replace_map)
slices = loop_slices + [
Slice(axis, utils.atom(component)) for axis, component in leaf_path.items()
]
slice_tree = pyop3.index_tree.IndexTree.from_iterable(slices)
leaf_assignee = assignee[slice_tree]
if leaf_assignee.size > 0:
leaf_assignee.assign(
leaf_expr,
eager=True,
eager_strategy="compile",
compiler_parameters={"propagate_negatives": True},
)
# step 3: replace axis vars with loop indices in the layouts
will_modify = len(loop_var_replace_map) > 0
layouts = {}
from pyop3.expr.base import get_loop_tree
loop_tree, _ = get_loop_tree(composite_dat) # NOTE: conflicts with loopified_shape above
for path_ in composite_dat.axis_tree.node_map:
orig_layout = assignee.axes.layouts2[loop_tree.leaf_path | path_]
new_layout = pyop3.visitors.replace(
orig_layout,
utils.invert_mapping(loop_var_replace_map),
assert_modified=will_modify,
)
layouts[path_] = new_layout
layouts = idict(layouts)
if linear:
layout = layouts[composite_dat.axis_tree.leaf_path]
return pyop3.expr.LinearDatBufferExpression(assignee.buffer, layout)
else:
return pyop3.expr.NonlinearDatBufferExpression(assignee.buffer, layouts)
# TODO: Better to just return the actual value probably...
[docs]
@functools.singledispatch
def estimate(expr: Any) -> numbers.Number:
raise TypeError(f"No handler defined for {type(expr).__name__}")
@estimate.register(numbers.Number)
def _(num):
return num
@estimate.register(Scalar)
def _(scalar) -> np.number:
return scalar.value
@estimate.register(pyop3.expr.Mul)
def _(mul: pyop3.expr.Mul) -> int:
return estimate(mul.a) * estimate(mul.b)
@estimate.register(pyop3.expr.BufferExpression)
def _(buffer_expr: pyop3.expr.BufferExpression) -> numbers.Number:
buffer = buffer_expr.buffer
if buffer.size > 10:
return buffer.max_value or 10
else:
return max(buffer.data_ro)
# TODO: it would be handy to have 'single=True' or similar as usually only one shape is here
# TODO: What is the appropriate return type? It's not just plain axis trees
[docs]
@functools.singledispatch
def get_shape(obj: Any, /) -> tuple[AxisTree, ...]:
raise TypeError(f"No handler defined for {type(obj).__name__}")
@get_shape.register(pyop3.expr.Operator)
def _(op: pyop3.expr.Operator, /) -> tuple[AxisTree, ...]:
return (
merge_axis_trees([
utils.just_one(get_shape(operand))
for operand in op.operands
]),
)
@get_shape.register
def _(axis_var: pyop3.expr.AxisVar, /) -> tuple[AxisTree, ...]:
return (axis_var.axis.as_tree(),)
@get_shape.register
def _(dat: pyop3.expr.Dat, /):
return (dat.axes,)
@get_shape.register
def _(mat: pyop3.expr.Mat, /):
return (mat.row_axes, mat.column_axes)
@get_shape.register
def _(cdat: pyop3.expr.CompositeDat, /) -> tuple[AxisTree]:
return (cdat.axis_tree,)
@get_shape.register
def _(dat_expr: pyop3.expr.LinearDatBufferExpression, /) -> tuple[AxisTree, ...]:
return get_shape(dat_expr.layout)
@get_shape.register
def _(dat_expr: pyop3.expr.NonlinearDatBufferExpression, /) -> tuple[AxisTree, ...]:
return (
pyop3.axis_tree.merge_axis_trees(
[get_shape(l)[0] for l in dat_expr.layouts.values()]
),
)
@get_shape.register(numbers.Number)
@get_shape.register(pyop3.expr.LoopIndexVar)
@get_shape.register(pyop3.expr.NaN)
@get_shape.register(pyop3.expr.ScalarBufferExpression)
@get_shape.register(pyop3.expr.Scalar)
def _(obj: Any, /) -> tuple[AxisTree, ...]:
return (UNIT_AXIS_TREE,)
# NOTE: Bit of a strange return type...
[docs]
@functools.singledispatch
def get_loop_axes(obj: Any) -> idict[LoopIndex: tuple[Axis, ...]]:
raise TypeError(f"No handler defined for {type(obj).__name__}")
@get_loop_axes.register(pyop3.expr.Operator)
def _(op: pyop3.expr.Operator, /) -> tuple[AxisTree, ...]:
# NOTE: could be cleaned up
a_loop_axes = get_loop_axes(op.a)
axes = collections.defaultdict(tuple, a_loop_axes)
for op in op.operands[1:]:
for loop_index, loop_axes in get_loop_axes(op).items():
axes[loop_index] = utils.unique((*axes[loop_index], *loop_axes))
return idict(axes)
@get_loop_axes.register(pyop3.expr.LinearDatBufferExpression)
def _(dat_expr: pyop3.expr.LinearDatBufferExpression, /):
return get_loop_axes(dat_expr.layout)
@get_loop_axes.register(pyop3.expr.LoopIndexVar)
def _(loop_var: pyop3.expr.LoopIndexVar, /):
return idict({loop_var.loop_index: (loop_var.axis,)})
@get_loop_axes.register(numbers.Number)
@get_loop_axes.register(pyop3.expr.AxisVar)
@get_loop_axes.register(pyop3.expr.NaN)
@get_loop_axes.register(pyop3.expr.ScalarBufferExpression)
def _(obj: Any, /):
return idict()
[docs]
@functools.singledispatch
def get_local_max(obj: Any) -> numbers.Number:
raise TypeError(f"No handler defined for {type(obj).__name__}")
@get_local_max.register(numbers.Number)
def _(num: numbers.Number) -> numbers.Number:
return num
@get_local_max.register(pyop3.expr.Expression)
def _(expr: pyop3.expr.Expression) -> numbers.Number:
return expr.local_max
[docs]
@functools.singledispatch
def get_local_min(obj: Any, /) -> numbers.Number:
raise TypeError(f"No handler defined for {type(obj).__name__}")
@get_local_min.register(numbers.Number)
def _(num: numbers.Number, /) -> numbers.Number:
return num
@get_local_min.register(pyop3.expr.Expression)
def _(expr: pyop3.expr.Expression, /) -> numbers.Number:
return expr.local_min
[docs]
def find_max_value(expr: pyop3.expr.Expression) -> numbers.Number:
return get_extremum(expr, "max")
[docs]
def find_min_value(expr: pyop3.expr.Expression) -> numbers.Number:
return get_extremum(expr, "min")
[docs]
def get_extremum(expr, extremum: Literal["max", "min"]) -> numbers.Number:
if extremum == "max":
fn = max_
else:
assert extremum == "min"
fn = min_
axes, loop_var_replace_map = loopified_shape(expr)
expr = pyop3.visitors.replace(expr, loop_var_replace_map)
loop_index = axes.iter()
# NOTE: might hit issues if things aren't linear
loop_var_replace_map = {
axis.label: pyop3.expr.LoopIndexVar(loop_index, axis)
for axis in axes.nodes
}
expr = replace_terminals(expr, loop_var_replace_map)
result = pyop3.expr.Dat.zeros(UNIT_AXIS_TREE, dtype=IntType)
loop_(
loop_index,
result.assign(fn(result, expr)),
eager=True
)
return utils.just_one(result.buffer.get_array())
[docs]
def max_(a, b, /, *, lazy: bool = False) -> pyop3.expr.Conditional | numbers.Number:
if not lazy:
return conditional(a > b, a, b)
else:
return pyop3.expr.Conditional(pyop3.expr.GreaterThan(a, b), a, b)
[docs]
def min_(a, b, /, *, lazy: bool = False) -> pyop3.expr.Conditional | numbers.Number:
if not lazy:
return conditional(a < b, a, b)
else:
return pyop3.expr.Conditional(pyop3.expr.LessThan(a, b), a, b)
[docs]
class ArgumentCollector(NodeCollector):
[docs]
@functools.singledispatchmethod
def process(self, obj: Any) -> OrderedFrozenSet:
return super().process(obj)
@process.register(pyop3.expr.Operator)
@postorder
def _(self, op: pyop3.expr.Operator, visited, /) -> OrderedFrozenSet:
return OrderedFrozenSet().union(*visited.values())
@process.register(numbers.Number)
@process.register(pyop3.expr.NaN)
@process.register(pyop3.expr.AxisVar)
@process.register(pyop3.expr.LoopIndexVar)
def _(self, expr: pyop3.expr.ExpressionT, /) -> OrderedFrozenSet:
return OrderedFrozenSet()
@process.register
def _(self, wref: weakref.ReferenceType, /):
return OrderedFrozenSet([wref])
# TODO: AbstractBufferExpression
@process.register(pyop3.expr.OpaqueTerminal)
@process.register(pyop3.expr.Tensor)
@process.register(pyop3.expr.BufferExpression)
def _(self, arg: Any, /) -> OrderedFrozenSet:
return OrderedFrozenSet([arg])
@process.register(pyop3.expr.AggregateDat)
@process.register(pyop3.expr.AggregateMat)
def _(self, agg_tensor: Any, /) -> OrderedFrozenSet:
return OrderedFrozenSet(agg_tensor.subtensors.flatten())
[docs]
def collect_arguments(expr: ExpressionT) -> OrderedFrozenSet:
return ArgumentCollector()(expr)
[docs]
class ExpressionLinearizer(NodeTransformer, ExpressionVisitor):
[docs]
@functools.singledispatchmethod
def process(self, obj: ExpressionT, /, **kwargs) -> ExpressionT:
return super().process(obj, **kwargs)
@process.register(numbers.Number)
@process.register(pyop3.expr.NaN) # NaN layouts are allowed for zero-sized trees
@process.register(pyop3.expr.Operator)
@process.register(pyop3.expr.AxisVar)
@process.register(pyop3.expr.LoopIndexVar)
@process.register(pyop3.expr.ScalarBufferExpression)
@process.register(pyop3.expr.LinearDatBufferExpression)
def _(self, expr: ExpressionT, /, **kwargs) -> ExpressionT:
return self.reuse_if_untouched(expr, **kwargs)
@process.register(pyop3.expr.NonlinearDatBufferExpression)
@postorder
def _(self, dat_expr: pyop3.expr.NonlinearDatBufferExpression, visited, /, *, path) -> None:
if path is None:
layout = utils.just_one(dat_expr.leaf_layouts.values())
else:
# find the best candidate layout looking at 'path', bearing
# in mind that the path might only be a partial match.
# consider expression: dat1[i] + dat2[j]
# the full path is i and j, but each component only 'sees' one of these.
layout = utils.just_one((
layout_
for path_, layout_ in dat_expr.leaf_layouts.items()
if is_subpath(path_, path)
))
return pyop3.expr.LinearDatBufferExpression(dat_expr.buffer, layout)
[docs]
def linearize_expr(expr: ExpressionT, path: PathT | None = None) -> ExpressionT:
return ExpressionLinearizer()(expr, path=path)
@expand_transforms.register
def _(op: pyop3.expr.UnaryOperator, /, access_type):
bare_a, unpack_insns = expand_transforms(op.a, access_type)
return (type(op)(bare_a), unpack_insns)
@expand_transforms.register
def _(op: pyop3.expr.BinaryOperator, /, access_type):
bare_a, a_unpack_insns = expand_transforms(op.a, access_type)
bare_b, b_unpack_insns = expand_transforms(op.b, access_type)
return (type(op)(bare_a, bare_b), a_unpack_insns+b_unpack_insns)
@expand_transforms.register
def _(op: pyop3.expr.TernaryOperator, /, access_type):
bare_operands = []
unpack_insns = []
for operand in op.operands:
bare_operand, operand_unpack_insns = expand_transforms(operand, access_type)
bare_operands.append(bare_operand)
unpack_insns.extend(operand_unpack_insns)
return (type(op)(*bare_operands), tuple(unpack_insns))
@expand_transforms.register(numbers.Number)
@expand_transforms.register(pyop3.expr.AxisVar)
@expand_transforms.register(pyop3.expr.LoopIndexVar)
@expand_transforms.register(pyop3.expr.BufferExpression)
@expand_transforms.register(pyop3.expr.NaN)
def _(var, /, access_type):
return (var, ())
@expand_transforms.register(pyop3.expr.AggregateDat)
@expand_transforms.register(pyop3.expr.AggregateMat)
def _(agg_tensor: pyop3.expr.AggregateMat, /, access_type):
temporary = agg_tensor.materialize()
if access_type == ArrayAccessType.READ:
insns = tuple(
temporary[ix].assign(submat, _weakref=False)
for ix, submat in agg_tensor
)
else:
mode = _array_access_type_to_mode(access_type)
insns = tuple(
submat.assign(temporary[ix], mode, _weakref=False)
for ix, submat in agg_tensor
)
return temporary, insns
def _array_access_type_to_mode(access_type):
match access_type:
case ArrayAccessType.WRITE:
return "write"
case ArrayAccessType.INC:
return "inc"
case ArrayAccessType.MAX:
return "max"
case ArrayAccessType.MIN:
return "min"
case _:
raise AssertionError
@expand_transforms.register(weakref.ReferenceType)
@expand_transforms.register(pyop3.expr.Tensor)
def _(tensor, /, access_type):
if isinstance(tensor, weakref.ReferenceType):
tensor = tensor()
assert isinstance(tensor, pyop3.expr.Tensor)
is_weakref = True
else:
is_weakref = False
if not tensor.transform:
if is_weakref:
tensor = weakref.ref(tensor)
return tensor, ()
else:
# safe to ignore weakref on this branch because tensor is getting reconstructed
bare_tensor = tensor.record_new(_transform=None)
return _expand_transforms_tensor(bare_tensor, tensor.transform, access_type)
def _expand_transforms_tensor(tensor: pyop3.expr.Tensor, transform: pyop3.expr.TensorTransform | None, access_type: ArrayAccessType):
# For more exposition on this function refer to pyop3/insn/visitors.py::expand_transforms
assert not tensor.transform, "Tensor transforms should already have been extracted"
if not transform:
if access_type in {ArrayAccessType.READ, ArrayAccessType.WRITE}:
return tensor, ()
else:
mode = _array_access_type_to_mode(access_type)
# For increment access we only want the preceding transformations
# to apply to the incremental change, not the whole data structure.
# We therefore materialise and return a temporary to hold the change.
temporary = tensor.materialize()
return temporary, (tensor.assign(temporary, mode, _weakref=False),)
prev_tensor = tensor
if isinstance(transform, ReshapeTensorTransform):
prev_tensor = tensor.with_axes(*transform.axis_trees)
# Start at the top of the transformation tree
prev_tensor, prev_insns = _expand_transforms_tensor(prev_tensor, transform.prev, access_type)
if isinstance(transform, ReshapeTensorTransform):
# Consider emitting code for the following operations
#
# for i < 3
# temp1[i] = dat[f(i)]
# for j < 3
# temp1[j+3] = dat[g(j)]
# for k < 6
# temp2[k] = temp1[h(k)]
#
# Here we use a reshape transformation to interpret 'dat' in 2 ways:
# first with a 2 component axis tree (each of size 3), and second as
# a single component with size 6. The permutation operation 'h(k)'
# cannot nicely compose with the former packing operations 'f(i)' and
# 'g(j)' so we handle it separately. This means that *reshape operations
# require intermediate temporaries*, which we handle here.
#
# This means that we need an instruction like
#
# temp[i] = global[f(i)]
#
# for packing, or
#
# global[f(i)] = temp[i]
#
# for unpacking. We already have 'global' and must form 'temp', which
# is then passed up to the caller. Critically note that 'temp' here must
# be interpretable in 2 ways, once as an unindexed temporary ('temp1[i]'
# and 'temp1[j+3]') above, and also with the indexing information
# encoded in its axis tree ('temp1[h(k)]' above).
# Make 'tensor' a temporary but retain its original axis tree, this is
# what we return to the caller
# tensor = tensor.null_like()
temp = prev_tensor.materialize()
# Produce an 'unindexed' version of this temporary with shape
# matching 'prev_tensor'
if isinstance(tensor, Dat):
temp_reshaped = temp.with_axes(tensor.axes)
else:
assert isinstance(tensor, Mat)
temp_reshaped = temp.with_axes(
tensor.row_axes,
tensor.column_axes,
)
if access_type == ArrayAccessType.READ:
insns = prev_insns + (
temp.assign(prev_tensor, _weakref=False),
)
return temp_reshaped, insns
else:
insns = (
prev_tensor.assign(temp, _weakref=False),
) + prev_insns
return temp_reshaped, insns
else:
assert isinstance(transform, OutOfPlaceCallableTensorTransform)
# Emit something like
#
# f_in(global, temp)
#
# for packing, or
#
# f_out(temp, global)
#
# for unpacking. We already have 'global' and must form 'temp', which
# is then passed up to the caller.
tensor = tensor.materialize()
if access_type == ArrayAccessType.READ:
insns = prev_insns + transform.transform_in(prev_tensor, tensor)
else:
insns = transform.transform_out(tensor, prev_tensor) + prev_insns
return tensor, insns