Source code for pyop3.expr.visitors

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)
[docs] @functools.singledispatch def expand_transforms(expr: Any, /, *args, **kwargs): raise TypeError(f"No handler provided for {type(expr).__name__}")
@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