Reference

Note

Expression trees based on this package are picklable as long as no non-picklable data (e.g. pyopencl.array.Array) is referenced from DataWrapper.

Array Interface

class pytato.Namespace

Represents a mapping from identifier strings to array expressions or None, where None indicates that the name may not be used. (Placeholder instances register their names in this way to avoid ambiguity.)

__contains__(name)

Return type

bool

__getitem__(name)

Return type

Array

__iter__()

Return type

Iterator[str]

__len__()

Return type

int

assign(name, value)

Declare a new array.

Parameters

• name (str) – a Python identifier

• value (Array) – the array object

Return type

str

Returns

name

copy()

Return type

Namespace

ref(name)

Return type

Array

Returns

An array expression referring to name.

class pytato.Array(namespace, tags=None)

A base class (abstract interface + supplemental functionality) for lazily evaluating array expressions. The interface seeks to maximize numpy compatibility, though not at all costs.

Objects of this type are hashable and support structural equality comparison (and are therefore immutable).

Note

Hashability and equality testing does break numpy compatibility, purposefully so.

FIXME: Point out our equivalent for numpy’s ==.

namespace

A (mutable) instance of Namespace containing the names used in the computation. All arrays in a computation share the same namespace.

shape

Identifiers (pymbolic.Variable) refer to names from namespace. A tuple of integers or pymbolic expressions. Shape may be (at most affinely) symbolic in these identifiers.

Note

Affine-ness is mainly required by code generation for IndexLambda, but IndexLambda is used to produce references to named arrays. Since any array that needs to be referenced in this way needs to obey this restriction anyway, a decision was made to requir the same of all array expressions.

dtype

An instance of numpy.dtype.

tags

A tuple of Tag instances.

Motivation: RDF triples (subject: implicitly the array being tagged, predicate: the tag, object: the arg).

named(name)

Return type

Array

tagged(tag)

Returns a copy of self tagged with tag. If tag is a UniqueTag and other tags of this type are already present, an error is raised.

Return type

Array

without_tag(tag, verify_existence=True)

Return type

Array

Derived attributes:

ndim

class pytato.Tag

Generic metadata, applied to, among other things, instances of Array.

tag_name

A fully qualified DottedName that reflects the class name of the tag.

Instances of this type must be immutable, hashable, picklable, and have a reasonably concise __repr__() of the form dotted.name(attr1=value1, attr2=value2). Positional arguments are not allowed.

Note

This mirrors the tagging scheme that loopy is headed towards.

class pytato.UniqueTag

Only one instance of this type of tag may be assigned to a single tagged object.

class pytato.DictOfNamedArrays(data)

A container that maps valid Python identifiers to instances of Array. May occur as a result type of array computations.

__contains__()

__getitem__()

__iter__()

__len__()

Note

This container deliberately does not implement arithmetic.

Supporting Functionality

class pytato.DottedName(name_parts)

name_parts

A tuple of strings, each of which is a valid Python identifier. No name part may start with a double underscore.

The name (at least morally) exists in the name space defined by the Python module system. It need not necessarily identify an importable object.

classmethod from_class(argcls)

Return type

DottedName

Concrete Array Data

class pytato.array.DataInterface(*args, **kwds)

A protocol specifying the minimal interface requirements for concrete array data supported by DataWrapper.

See typing.Protocol for more information about protocols.

Code generation targets may impose additional restrictions on the kinds of concrete array data they support.

shape

dtype

Pre-Defined Tags

class pytato.array.ImplementAs(strategy: pytato.array.ImplementationStrategy)

strategy

class pytato.array.CountNamed(name: str)

name

class pytato.array.ImplStored

class pytato.array.ImplInlined

class pytato.array.ImplDefault

Built-in Expression Nodes

class pytato.array.IndexLambda(namespace, expr, shape, dtype, bindings=None, tags=None)

expr

A scalar-valued pymbolic expression such as a[_1] + b[_2, _1].

Identifiers in the expression are resolved, in order, by lookups in bindings, then in namespace.

Scalar functions in this expression must be identified by a dotted name representing a Python object (e.g. pytato.c99.sin).

bindings

A dict mapping strings that are valid Python identifiers to objects implementing the Array interface, making array expressions available for use in expr.

is_reference()

Return type

bool

class pytato.array.Einsum(namespace, tags=None)

class pytato.array.Reshape(namespace, tags=None)

class pytato.array.DataWrapper(namespace, data, tags=None)

Takes concrete array data and packages it to be compatible with the Array interface.

data

A concrete array (containing data), given as, for example, a numpy.ndarray, or a pyopencl.array.Array. This must offer shape and dtype attributes but is otherwise considered opaque. At evaluation time, its type must be understood by the appropriate execution backend.

Starting with the construction of the DataWrapper, this array may not be updated in-place.

class pytato.array.Placeholder(namespace, name, shape, dtype, tags=None)

A named placeholder for an array whose concrete value is supplied by the user during evaluation.

name

The name by which a value is supplied for the placeholder once computation begins. The name is also implicitly assign()ed in the Namespace.

Note

Creating multiple instances of a Placeholder with the same name and within the same Namespace is not allowed.

class pytato.array.LoopyFunction(data)

Note

This should allow both a locally stored kernel and one that’s obtained by importing a dotted name.

User-Facing Node Creation

Node constructors such as Placeholder.__init__ and DictOfNamedArrays.__init__ offer limited input validation (in favor of faster execution). Node creation from outside pytato should use the following interfaces:

class pytato.array.ConvertibleToShape

pytato.array.make_dict_of_named_arrays(data)

Make a DictOfNamedArrays object and ensure that all arrays share the same namespace.

Parameters

data (Dict[str, Array]) – member keys and arrays

Return type

DictOfNamedArrays

pytato.array.make_placeholder(namespace, name, shape, dtype, tags=None)

Make a Placeholder object.

Parameters

• namespace (Namespace) – namespace of the placeholder array

• name (str) – name of the placeholder array

• shape (Union[str, Number, Expression, Tuple[Union[int, Expression, str], …]]) – shape of the placeholder array

• dtype (dtype) – dtype of the placeholder array

• tags (Optional[FrozenSet[Tag]]) – implementation tags

Return type

Placeholder

Scalar Expressions

pytato.scalar_expr.ScalarExpression

A type for scalar-valued symbolic expressions. Expressions are composable and manipulable via pymbolic.

Concretely, this is an alias for Union[Number, pymbolic.primitives.Expression].

pytato.scalar_expr.parse(s)

Return type

Union[Number, Expression]

pytato.scalar_expr.get_dependencies(expression)

Return the set of variable names in an expression.

Parameters

expression (Any) – A scalar expression, or an expression derived from such (e.g., a tuple of scalar expressions)

Return type

FrozenSet[str]

pytato.scalar_expr.substitute(expression, variable_assigments)

Perform variable substitution in an expression.

Parameters

• expression (Any) – A scalar expression, or an expression derived from such (e.g., a tuple of scalar expressions)

• variable_assigments (Mapping[str, Any]) – A mapping from variable names to substitutions

Return type

Any

Transforming Computations

class pytato.transform.Mapper

Generated Executable Programs

class pytato.program.BoundProgram(program: lp.LoopKernel, bound_arguments: Mapping[str, Any], target: pytato.target.Target)

A wrapper around a loopy kernel for execution.

program

The underlying loopy.LoopKernel.

target

The code generation target.

bound_arguments

A map from names to pre-bound kernel arguments.

__call__(*args, **kwargs)

Call self as a function.

Return type

Any

class pytato.program.BoundPyOpenCLProgram(program: lp.LoopKernel, bound_arguments: Mapping[str, Any], target: pytato.target.Target, queue: Optional[cl.CommandQueue])

A wrapper around a loopy kernel for execution with pyopencl.

queue

A pyopencl command queue.

__call__(*args, **kwargs)

Convenience function for launching a pyopencl computation.

Return type

Any

Code Generation Targets

class pytato.target.Target

An abstract code generation target.

get_loopy_target()

Return the corresponding loopy target.

Return type

ForwardRef

bind_program(program, bound_arguments)

Create a pytato.program.BoundProgram for this code generation target.

Parameters

• program (ForwardRef) – the loopy kernel

• bound_arguments (Mapping[str, Any]) – a mapping from argument names to outputs

Return type

BoundProgram

class pytato.target.PyOpenCLTarget(queue=None)

A pyopencl code generation target.

queue

The pyopencl command queue, or None.

Generating Code

pytato.generate_loopy(result, target=None, options=None)

Code generation entry point.

Parameters

• result (Union[Array, DictOfNamedArrays]) – Outputs of the computation.

• target (Optional[Target]) – Code generation target.

• options (Optional[Options]) – Code generation options for the kernel.

Return type

BoundProgram

Returns

A wrapped generated loopy kernel

Code Generation Internals

class pytato.codegen.LoopyExpressionContext(state: pytato.codegen.CodeGenState, _depends_on: FrozenSet[str] = <factory>, local_namespace: Mapping[str, pytato.array.Array] = <factory>, reduction_bounds: Dict[str, Tuple[Union[numbers.Number, pymbolic.primitives.Expression], Union[numbers.Number, pymbolic.primitives.Expression]]] = <factory>)

Mutable state used while generating loopy expressions. Wraps CodeGenState with more expression-specific information.

This data is passed through InlinedExpressionGenMapper via arguments, and is also used by ImplementedResult.to_loopy_expression() to retrieve contextual data.

state

The CodeGenState.

local_namespace

A (read-only) local name mapping used for name lookup when generating code.

depends_on

The set of statement IDs that need to be included in loopy.InstructionBase.depends_on.

reduction_bounds

A mapping from inames to reduction bounds in the expression.

update_depends_on(other)

Return type

None

lookup(name)

Return type

Array

class pytato.codegen.ImplementedResult(array)

Generated code for a node in the computation graph (i.e., an array expression).

array

The pytato.Array associated with this code.

to_loopy_expression(indices, expr_context)

Return a loopy expression for this result.

Return type

Union[Number, Expression]

class pytato.codegen.StoredResult(name, array)

An array expression generated as a loopy array.

See also: pytato.array.ImplStored.

class pytato.codegen.InlinedResult(expr, array)

An array expression generated as a loopy expression containing inlined sub-expressions.

See also: pytato.array.ImplInlined.

class pytato.codegen.SubstitutionRuleResult(array)

class pytato.codegen.CodeGenState(namespace: Mapping[str, pytato.array.Array], _kernel: loopy.kernel.LoopKernel, results: Dict[pytato.array.Array, pytato.codegen.ImplementedResult])

A container for data kept by CodeGenMapper.

namespace

The (global) namespace

kernel

The partial loopy.LoopKernel being built.

results

A mapping from pytato.Array instances to instances of ImplementedResult.

var_name_gen

insn_id_gen

update_kernel(kernel)

Return type

None

class pytato.codegen.CodeGenMapper

A mapper for generating code for nodes in the computation graph.

class pytato.codegen.InlinedExpressionGenMapper(codegen_mapper)

A mapper for generating loopy expressions with inlined sub-expressions.

The inputs to this mapper are scalar expression as found in pytato.array.IndexLambda, or expressions that are compatible (e.g., shape expressions).

The outputs of this mapper are scalar expressions suitable for wrapping in InlinedResult.

pytato.codegen.domain_for_shape(dim_names, shape)

Create an islpy.BasicSet that expresses an appropriate index domain for an array of (potentially symbolic) shape shape.

Parameters

• dim_names (Tuple[str, …]) – A tuple of strings, the names of the axes. These become set dimensions in the returned domain.

• shape (Tuple[Union[Number, Expression], …]) – A tuple of constant or quasi-affine pymbolic expressions. The variables in these expressions become parameter dimensions in the returned set. Must have the same length as dim_names.

Return type

BasicSet

pytato.codegen.add_output(name, expr, state, mapper)

Add an output argument to the kernel.

Return type

None