from __future__ import annotations
import abc
import functools
import numbers
import weakref
from collections.abc import Hashable
from typing import TYPE_CHECKING, Any
import numpy as np
from immutabledict import immutabledict as idict
import pyop3.axis_tree
import pyop3.buffer
import pyop3.record
from pyop3 import utils
from pyop3.buffer import AbstractBuffer
from pyop3.collections import OrderedFrozenSet
from pyop3.labeled_tree import is_subpath
from .base import Expression, as_str
from .tensor import Dat, Scalar
if TYPE_CHECKING:
from pyop3.types import *
# TODO: Should inherit from Terminal (but Terminal has odd attrs)
[docs]
class BufferExpression(Expression, metaclass=abc.ABCMeta):
__abstract_record_attrs = ("buffer_view",)
@property
def name(self) -> str:
return self.buffer_view.buffer.name
@property
def dtype(self) -> np.dtype:
return self.buffer_view.buffer.dtype
# used?
[docs]
def assign(self, other, *, _weakref: bool = True) -> pyop3.insn.Assignment:
from pyop3.insn import Assignment
assignee = weakref.ref(self) if _weakref else self
return Assignment(assignee, other, "write")
# used?
[docs]
def iassign(self, other, *, _weakref: bool = True) -> pyop3.insn.Assignment:
from pyop3.insn import Assignment
assignee = weakref.ref(self) if _weakref else self
return Assignment(assignee, other, "inc")
@property
def buffer(self) -> pyop3.buffer.AbstractBuffer:
assert self.buffer_view.nest_indices == (), \
"Direct access to 'buffer' is ambiguous for nests"
return self.buffer_view.buffer
[docs]
@pyop3.record.frozenrecord()
class ScalarBufferExpression(BufferExpression):
# {{{ instance attrs
buffer_view: pyop3.buffer.IndexedBuffer
[docs]
def collect_buffers(self, visitor):
return visitor(self.buffer_view)
[docs]
def get_disk_cache_key(self, visitor) -> Hashable:
return (type(self), visitor(self.buffer_view))
get_instruction_executor_cache_key = get_disk_cache_key
def __init__(self, buffer_view: AbstractBuffer | pyop3.buffer.IndexedBuffer) -> None:
if isinstance(buffer_view, pyop3.buffer.AbstractBuffer):
assert buffer_view.nest_shape() is None
buffer_view = pyop3.buffer.IndexedBuffer(buffer_view, ())
object.__setattr__(self, "buffer_view", buffer_view)
# }}}
# {{{ interface impls
child_attrs = ()
@property
def local_max(self) -> numbers.Number:
return self.value
@property
def local_min(self) -> numbers.Number:
return self.value
@property
def _full_str(self) -> str:
return self.name
# def __add__(self, other: ExpressionT, /) -> ExpressionT:
# if self.buffer.constant:
# if isinstance(other, numbers.Number):
# buffer = ArrayBuffer.from_scalar(self.value+other, constant=True, dtype=self.dtype)
# return type(self)(buffer)
# elif type(other) is type(self) and other.buffer.constant:
# buffer = ArrayBuffer.from_scalar(self.value+other.value, constant=True, dtype=self.dtype)
# return type(self)(buffer)
# return super().__add__(other)
#
# def __sub__(self, other: ExpressionT, /) -> ExpressionT:
# if self.buffer.constant:
# if isinstance(other, numbers.Number):
# buffer = ArrayBuffer.from_scalar(self.value-other, constant=True, dtype=self.dtype)
# return type(self)(buffer)
# elif type(other) is type(self) and other.buffer.constant:
# buffer = ArrayBuffer.from_scalar(self.value-other.value, constant=True, dtype=self.dtype)
# return type(self)(buffer)
# return super().__sub__(other)
#
# def __mul__(self, other: ExpressionT, /) -> ExpressionT:
# if self.buffer.constant:
# if isinstance(other, numbers.Number):
# buffer = ArrayBuffer.from_scalar(self.value*other, constant=True, dtype=self.dtype)
# return type(self)(buffer)
# elif type(other) is type(self) and other.buffer.constant:
# buffer = ArrayBuffer.from_scalar(self.value*other.value, constant=True, dtype=self.dtype)
# return type(self)(buffer)
# return super().__mul__(other)
# }}}
@property
def value(self) -> numbers.Number:
return self.buffer_view.buffer.data_ro.item()
# TODO: Does a Dat count as one of these?
[docs]
class DatBufferExpression(BufferExpression, metaclass=abc.ABCMeta):
pass
[docs]
class LinearBufferExpression(BufferExpression, metaclass=abc.ABCMeta):
pass
[docs]
class NonlinearBufferExpression(BufferExpression, metaclass=abc.ABCMeta):
pass
[docs]
@pyop3.record.frozenrecord()
class LinearDatBufferExpression(DatBufferExpression, LinearBufferExpression):
"""A dat with fixed (?) layout.
It cannot be indexed.
This class is useful for describing arrays used in index expressions, at which
point it has a fixed set of axes.
"""
# {{{ instance attrs
buffer_view: pyop3.buffer.IndexedBuffer
layout: Any
[docs]
def collect_buffers(self, visitor):
return visitor(self.buffer_view) | visitor(self.layout)
[docs]
def get_disk_cache_key(self, visitor) -> Hashable:
return (type(self), visitor(self.buffer_view), visitor(self.layout))
[docs]
def get_instruction_executor_cache_key(self, visitor) -> Hashable:
buffer_key = visitor(self.buffer_view)
with visitor.identity_hash_buffers():
layout_key = visitor(self.layout)
return (type(self), buffer_key, layout_key)
@property
def comm(self):
return self.buffer_view.comm
def __init__(self, buffer_view, layout):
if isinstance(buffer_view, pyop3.buffer.AbstractBuffer):
assert buffer_view.nest_shape() is None
buffer_view = pyop3.buffer.IndexedBuffer(buffer_view, ())
object.__setattr__(self, "buffer_view", buffer_view)
object.__setattr__(self, "layout", layout)
# }}}
# {{{ interface impls
child_attrs = ("layout",)
@property
def local_max(self) -> numbers.Number:
from pyop3.expr.visitors import get_extremum
return get_extremum(self, "max")
@property
def local_min(self) -> numbers.Number:
from pyop3.expr.visitors import get_extremum
return get_extremum(self, "min")
@property
def _full_str(self) -> str:
return f"{self.name}[{as_str(self.layout)}]"
# }}}
[docs]
def concretize(self):
return self
[docs]
@pyop3.record.frozenrecord()
class NonlinearDatBufferExpression(DatBufferExpression, NonlinearBufferExpression):
"""A dat with fixed layouts.
This class is useful for describing dats whose layouts have been optimised.
"""
# {{{ instance attrs
buffer_view: pyop3.buffer.IndexedBuffer
layouts: idict
[docs]
def get_disk_cache_key(self, visitor) -> Hashable:
layouts_key = {}
for path, layout in self.layouts.items():
layouts_key[visitor.relabel_axis_tree_path(path)] = visitor(layout)
layouts_key = idict(layouts_key)
return (type(self), visitor(self.buffer_view), layouts_key)
[docs]
def collect_buffers(self, visitor):
return visitor(self.buffer_view).union(*(map(visitor, self.layouts.values())))
def __init__(self, buffer_view, layouts) -> None:
if isinstance(buffer_view, pyop3.buffer.AbstractBuffer):
assert buffer_view.nest_shape() is None
buffer_view = pyop3.buffer.IndexedBuffer(buffer_view, ())
object.__setattr__(self, "buffer_view", buffer_view)
object.__setattr__(self, "layouts", layouts)
# }}}
@property
def comm(self):
return self.buffer_view.comm
# {{{ interface impls
child_attrs = ("layouts",)
@property
def local_max(self) -> numbers.Number:
raise NotImplementedError
@property
def local_min(self) -> numbers.Number:
raise NotImplementedError
@property
def _full_str(self) -> str:
return " :: ".join(
f"{self.buffer_view.name}[{as_str(layout)}]"
for layout in self.layouts.values()
)
# }}}
@property
def leaf_layouts(self) -> idict:
leaf_layouts_ = {}
for path, layout in self.layouts.items():
if not any(
is_subpath(path, other_path)
for other_path in self.layouts.keys()
if other_path != path
):
leaf_layouts_[path] = layout
return idict(leaf_layouts_)
[docs]
def linearize(self, path, *, allow_partial: bool = False) -> LinearDatBufferExpression:
if allow_partial:
path = utils.just_one(
lpath
for lpath in self.layouts.keys()
if lpath.keys() <= path.keys()
)
return LinearDatBufferExpression(self.buffer_view, self.layouts[path])
[docs]
class MatBufferExpression(BufferExpression):
pass
[docs]
@pyop3.record.frozenrecord()
class MatPetscMatBufferExpression(MatBufferExpression, LinearBufferExpression):
# {{{ instance attrs
buffer_view: pyop3.buffer.IndexedBuffer
row_layout: ExpressionT
column_layout: ExpressionT
[docs]
def collect_buffers(self, visitor):
return visitor(self.buffer_view).union(visitor(self.row_layout), visitor(self.column_layout))
[docs]
def get_disk_cache_key(self, visitor) -> Hashable:
return (
type(self),
visitor(self.buffer_view),
visitor(self.row_layout),
visitor(self.column_layout),
)
# }}}
# {{{ interface impls
child_attrs = ("row_layout", "column_layout")
@property
def local_max(self) -> numbers.Number:
raise NotImplementedError
@property
def local_min(self) -> numbers.Number:
raise NotImplementedError
@property
def _full_str(self) -> str:
return f"{self.buffer_view.name}[{as_str(self.row_layout)}, {as_str(self.column_layout)}]"
# }}}
[docs]
@pyop3.record.frozenrecord()
class MatArrayBufferExpression(MatBufferExpression, NonlinearBufferExpression):
# {{{ instance attrs
buffer_view: pyop3.buffer.IndexedBuffer
row_layouts: idict
column_layouts: idict
[docs]
def collect_buffers(self, visitor) -> OrderedFrozenSet:
return visitor(self.buffer_view).union(
*(map(visitor, self.row_layouts.values())),
*(map(visitor, self.column_layouts.values())),
)
[docs]
def get_disk_cache_key(self, visitor) -> Hashable:
row_layouts_key = idict({
visitor.relabel_axis_tree_path(path): visitor(layout)
for path, layout in self.row_layouts.items()
})
column_layouts_key = idict({
visitor.relabel_axis_tree_path(path): visitor(layout)
for path, layout in self.column_layouts.items()
})
return (type(self), visitor(self.buffer_view), row_layouts_key, column_layouts_key)
def __init__(self, buffer_view, row_layouts, column_layouts):
if isinstance(buffer_view, pyop3.buffer.AbstractBuffer):
assert buffer_view.nest_shape() is None
buffer_view = pyop3.buffer.IndexedBuffer(buffer_view, ())
object.__setattr__(self, "buffer_view", buffer_view)
object.__setattr__(self, "row_layouts", row_layouts)
object.__setattr__(self, "column_layouts", column_layouts)
# }}}
# {{{ interface impls
child_attrs = ("row_layouts", "column_layouts")
@property
def local_max(self) -> numbers.Number:
raise NotImplementedError
@property
def local_min(self) -> numbers.Number:
raise NotImplementedError
@property
def _full_str(self) -> str:
return f"{self.buffer_view.buffer.name}[{self.row_layouts}, {self.column_layouts}]"
# }}}
[docs]
def as_linear_buffer_expression(obj):
return _as_linear_buffer_expression(obj)
@functools.singledispatch
def _as_linear_buffer_expression(obj: Any) -> LinearDatBufferExpression:
raise TypeError
@_as_linear_buffer_expression.register
def _(expr: LinearDatBufferExpression) -> LinearDatBufferExpression:
return expr
# TODO: This is the same as dat.concretize(linear=True)
@_as_linear_buffer_expression.register
def _(dat: Dat) -> LinearDatBufferExpression:
assert dat.transform is None
if not dat.axes.is_linear:
raise ValueError("The provided dat must be linear")
axes = dat.axes.regionless()
# We assume that if we hit an axis forest at this point then any layout
# expression is valid.
# This can happen if we use maps with multiple possible matches (e.g. mapping
# from cells or owned cells).
if isinstance(axes, pyop3.axis_tree.AxisForest):
# FIXME, merge?
axes = axes.trees[-1]
ibuffer = pyop3.buffer.IndexedBuffer(dat.buffer, ())
layout = utils.just_one(axes.leaf_subst_layouts.values())
return LinearDatBufferExpression(ibuffer, layout)
@_as_linear_buffer_expression.register
def _(scalar: Scalar) -> ScalarBufferExpression:
assert scalar.transform is None
return ScalarBufferExpression(scalar.buffer)
@_as_linear_buffer_expression.register
def _(array: np.ndarray) -> LinearDatBufferExpression:
return _as_linear_buffer_expression(Dat.from_array(array))