diff --git a/doc/index.rst b/doc/index.rst
index d862a8acd0cb258bfd1e9623bd5cef895871f6b1..b77bbb16f413defe5010c75d28464051553b4486 100644
--- a/doc/index.rst
+++ b/doc/index.rst
@@ -25,18 +25,18 @@ Want to try out loopy?
There's no need to go through :ref:`installation` if you'd just like to get a
feel for what loopy is. Instead, you may
-`download a self-contained Linux binary <https://gitlab.tiker.net/inducer/loopy/builds/36708/artifacts/browse/build-helpers/>`_.
+`download a self-contained Linux binary <https://gitlab.tiker.net/inducer/loopy/-/jobs/66778/artifacts/browse/build-helpers/>`_.
This is purposefully built on an ancient Linux distribution, so it should work
on most versions of Linux that are currently out there.
Once you have the binary, do the following::
chmod +x ./loopy-centos6
- ./loopy-centos6 --target=opencl hello-loopy-lp.py
- ./loopy-centos6 --target=cuda hello-loopy-lp.py
- ./loopy-centos6 --target=ispc hello-loopy-lp.py
+ ./loopy-centos6 --target=opencl hello-loopy.loopy
+ ./loopy-centos6 --target=cuda hello-loopy.loopy
+ ./loopy-centos6 --target=ispc hello-loopy.loopy
-Grab the example here: :download:`examples/python/hello-loopy.py <../examples/python/hello-loopy-lp.py>`.
+Grab the example here: :download:`examples/python/hello-loopy.loopy <../examples/python/hello-loopy.loopy>`.
You may also donwload the most recent version by going to the `list of builds
<https://gitlab.tiker.net/inducer/loopy/builds>`_, clicking on the newest one
diff --git a/doc/ref_kernel.rst b/doc/ref_kernel.rst
index c9ce206260c04fc883a0f980df0b18a9a826bbd9..896388d2911a6d3c0e7783d7b1b3833b87c770d0 100644
--- a/doc/ref_kernel.rst
+++ b/doc/ref_kernel.rst
@@ -406,7 +406,7 @@ Arguments
:members:
:undoc-members:
-.. autoclass:: GlobalArg
+.. autoclass:: ArrayArg
:members:
:undoc-members:
@@ -593,7 +593,7 @@ Do not create :class:`LoopKernel` objects directly. Instead, refer to
Implementation Detail: The Base Array
-------------------------------------
-All array-like data in :mod:`loopy` (such as :class:`GlobalArg` and
+All array-like data in :mod:`loopy` (such as :class:`ArrayArg` and
:class:`TemporaryVariable`) derive from single, shared base array type,
described next.
diff --git a/doc/tutorial.rst b/doc/tutorial.rst
index 1272d2a59119725a903fa7cd1a08b7de8629c6f6..397f34a987ed336795d00e2770c2fbeadf089ae7 100644
--- a/doc/tutorial.rst
+++ b/doc/tutorial.rst
@@ -1361,7 +1361,7 @@ code-generation however additional implementation may be required for custom
functions. The full lists of available functions may be found in a the
:class:`TargetBase` implementation (e.g. :class:`CudaTarget`)
-Custom user functions may be represented using the method described in :ref:`_functions`
+Custom user functions may be represented using the method described in :ref:`functions`
Data-dependent control flow
@@ -1641,15 +1641,15 @@ we'll continue using the kernel from the previous example:
>>> mem_map = lp.get_mem_access_map(knl, subgroup_size=32)
>>> print(lp.stringify_stats_mapping(mem_map))
- MemAccess(global, np:dtype('float32'), {}, {}, load, a, subgroup) : ...
+ MemAccess(global, np:dtype('float32'), {}, {}, load, a, None, subgroup) : ...
<BLANKLINE>
Each line of output will look roughly like::
- MemAccess(global, np:dtype('float32'), {}, {}, load, a, subgroup) : [m, l, n] -> { 2 * m * l * n : m > 0 and l > 0 and n > 0 }
- MemAccess(global, np:dtype('float32'), {}, {}, load, b, subgroup) : [m, l, n] -> { m * l * n : m > 0 and l > 0 and n > 0 }
- MemAccess(global, np:dtype('float32'), {}, {}, store, c, subgroup) : [m, l, n] -> { m * l * n : m > 0 and l > 0 and n > 0 }
+ MemAccess(global, np:dtype('float32'), {}, {}, load, a, None, subgroup) : [m, l, n] -> { 2 * m * l * n : m > 0 and l > 0 and n > 0 }
+ MemAccess(global, np:dtype('float32'), {}, {}, load, b, None, subgroup) : [m, l, n] -> { m * l * n : m > 0 and l > 0 and n > 0 }
+ MemAccess(global, np:dtype('float32'), {}, {}, store, c, None, subgroup) : [m, l, n] -> { m * l * n : m > 0 and l > 0 and n > 0 }
:func:`loopy.get_mem_access_map` returns a :class:`loopy.ToCountMap` of **{**
:class:`loopy.MemAccess` **:** :class:`islpy.PwQPolynomial` **}**.
@@ -1684,13 +1684,13 @@ We can evaluate these polynomials using :func:`islpy.eval_with_dict`:
.. doctest::
- >>> f64ld_g = mem_map[lp.MemAccess('global', np.float64, {}, {}, 'load', 'g', CG.SUBGROUP)
+ >>> f64ld_g = mem_map[lp.MemAccess('global', np.float64, {}, {}, 'load', 'g', None, CG.SUBGROUP)
... ].eval_with_dict(param_dict)
- >>> f64st_e = mem_map[lp.MemAccess('global', np.float64, {}, {}, 'store', 'e', CG.SUBGROUP)
+ >>> f64st_e = mem_map[lp.MemAccess('global', np.float64, {}, {}, 'store', 'e', None, CG.SUBGROUP)
... ].eval_with_dict(param_dict)
- >>> f32ld_a = mem_map[lp.MemAccess('global', np.float32, {}, {}, 'load', 'a', CG.SUBGROUP)
+ >>> f32ld_a = mem_map[lp.MemAccess('global', np.float32, {}, {}, 'load', 'a', None, CG.SUBGROUP)
... ].eval_with_dict(param_dict)
- >>> f32st_c = mem_map[lp.MemAccess('global', np.float32, {}, {}, 'store', 'c', CG.SUBGROUP)
+ >>> f32st_c = mem_map[lp.MemAccess('global', np.float32, {}, {}, 'store', 'c', None, CG.SUBGROUP)
... ].eval_with_dict(param_dict)
>>> print("f32 ld a: %i\nf32 st c: %i\nf64 ld g: %i\nf64 st e: %i" %
... (f32ld_a, f32st_c, f64ld_g, f64st_e))
@@ -1708,13 +1708,13 @@ using :func:`loopy.ToCountMap.to_bytes` and :func:`loopy.ToCountMap.group_by`:
>>> bytes_map = mem_map.to_bytes()
>>> print(lp.stringify_stats_mapping(bytes_map))
- MemAccess(global, np:dtype('float32'), {}, {}, load, a, subgroup) : ...
+ MemAccess(global, np:dtype('float32'), {}, {}, load, a, None, subgroup) : ...
<BLANKLINE>
>>> global_ld_st_bytes = bytes_map.filter_by(mtype=['global']
... ).group_by('direction')
>>> print(lp.stringify_stats_mapping(global_ld_st_bytes))
- MemAccess(None, None, None, None, load, None, None) : ...
- MemAccess(None, None, None, None, store, None, None) : ...
+ MemAccess(None, None, None, None, load, None, None, None) : ...
+ MemAccess(None, None, None, None, store, None, None, None) : ...
<BLANKLINE>
>>> loaded = global_ld_st_bytes[lp.MemAccess(direction='load')
... ].eval_with_dict(param_dict)
@@ -1726,12 +1726,12 @@ using :func:`loopy.ToCountMap.to_bytes` and :func:`loopy.ToCountMap.group_by`:
The lines of output above might look like::
- MemAccess(global, np:dtype('float32'), {}, {}, load, a, subgroup) : [m, l, n] -> { 8 * m * l * n : m > 0 and l > 0 and n > 0 }
- MemAccess(global, np:dtype('float32'), {}, {}, load, b, subgroup) : [m, l, n] -> { 4 * m * l * n : m > 0 and l > 0 and n > 0 }
- MemAccess(global, np:dtype('float32'), {}, {}, store, c, subgroup) : [m, l, n] -> { 4 * m * l * n : m > 0 and l > 0 and n > 0 }
- MemAccess(global, np:dtype('float64'), {}, {}, load, g, subgroup) : [m, l, n] -> { 8 * m * n : m > 0 and l > 0 and n > 0 }
- MemAccess(global, np:dtype('float64'), {}, {}, load, h, subgroup) : [m, l, n] -> { 8 * m * n : m > 0 and l > 0 and n > 0 }
- MemAccess(global, np:dtype('float64'), {}, {}, store, e, subgroup) : [m, l, n] -> { 8 * m * n : m > 0 and l > 0 and n > 0 }
+ MemAccess(global, np:dtype('float32'), {}, {}, load, a, None, subgroup) : [m, l, n] -> { 8 * m * l * n : m > 0 and l > 0 and n > 0 }
+ MemAccess(global, np:dtype('float32'), {}, {}, load, b, None, subgroup) : [m, l, n] -> { 4 * m * l * n : m > 0 and l > 0 and n > 0 }
+ MemAccess(global, np:dtype('float32'), {}, {}, store, c, None, subgroup) : [m, l, n] -> { 4 * m * l * n : m > 0 and l > 0 and n > 0 }
+ MemAccess(global, np:dtype('float64'), {}, {}, load, g, None, subgroup) : [m, l, n] -> { 8 * m * n : m > 0 and l > 0 and n > 0 }
+ MemAccess(global, np:dtype('float64'), {}, {}, load, h, None, subgroup) : [m, l, n] -> { 8 * m * n : m > 0 and l > 0 and n > 0 }
+ MemAccess(global, np:dtype('float64'), {}, {}, store, e, None, subgroup) : [m, l, n] -> { 8 * m * n : m > 0 and l > 0 and n > 0 }
One can see how these functions might be useful in computing, for example,
achieved memory bandwidth in byte/sec or performance in FLOP/sec.
@@ -1751,12 +1751,12 @@ this time.
... outer_tag="l.1", inner_tag="l.0")
>>> mem_map = lp.get_mem_access_map(knl_consec, subgroup_size=32)
>>> print(lp.stringify_stats_mapping(mem_map))
- MemAccess(global, np:dtype('float32'), {0: 1, 1: 128}, {}, load, a, workitem) : ...
- MemAccess(global, np:dtype('float32'), {0: 1, 1: 128}, {}, load, b, workitem) : ...
- MemAccess(global, np:dtype('float32'), {0: 1, 1: 128}, {}, store, c, workitem) : ...
- MemAccess(global, np:dtype('float64'), {0: 1, 1: 128}, {}, load, g, workitem) : ...
- MemAccess(global, np:dtype('float64'), {0: 1, 1: 128}, {}, load, h, workitem) : ...
- MemAccess(global, np:dtype('float64'), {0: 1, 1: 128}, {}, store, e, workitem) : ...
+ MemAccess(global, np:dtype('float32'), {0: 1, 1: 128}, {}, load, a, None, workitem) : ...
+ MemAccess(global, np:dtype('float32'), {0: 1, 1: 128}, {}, load, b, None, workitem) : ...
+ MemAccess(global, np:dtype('float32'), {0: 1, 1: 128}, {}, store, c, None, workitem) : ...
+ MemAccess(global, np:dtype('float64'), {0: 1, 1: 128}, {}, load, g, None, workitem) : ...
+ MemAccess(global, np:dtype('float64'), {0: 1, 1: 128}, {}, load, h, None, workitem) : ...
+ MemAccess(global, np:dtype('float64'), {0: 1, 1: 128}, {}, store, e, None, workitem) : ...
<BLANKLINE>
With this parallelization, consecutive work-items will access consecutive array
@@ -1766,13 +1766,13 @@ array accesses has not changed:
.. doctest::
- >>> f64ld_g = mem_map[lp.MemAccess('global', np.float64, {0: 1, 1: 128}, {}, 'load', 'g', CG.WORKITEM)
+ >>> f64ld_g = mem_map[lp.MemAccess('global', np.float64, {0: 1, 1: 128}, {}, 'load', 'g', None, CG.WORKITEM)
... ].eval_with_dict(param_dict)
- >>> f64st_e = mem_map[lp.MemAccess('global', np.float64, {0: 1, 1: 128}, {}, 'store', 'e', CG.WORKITEM)
+ >>> f64st_e = mem_map[lp.MemAccess('global', np.float64, {0: 1, 1: 128}, {}, 'store', 'e', None, CG.WORKITEM)
... ].eval_with_dict(param_dict)
- >>> f32ld_a = mem_map[lp.MemAccess('global', np.float32, {0: 1, 1: 128}, {}, 'load', 'a', CG.WORKITEM)
+ >>> f32ld_a = mem_map[lp.MemAccess('global', np.float32, {0: 1, 1: 128}, {}, 'load', 'a', None, CG.WORKITEM)
... ].eval_with_dict(param_dict)
- >>> f32st_c = mem_map[lp.MemAccess('global', np.float32, {0: 1, 1: 128}, {}, 'store', 'c', CG.WORKITEM)
+ >>> f32st_c = mem_map[lp.MemAccess('global', np.float32, {0: 1, 1: 128}, {}, 'store', 'c', None, CG.WORKITEM)
... ].eval_with_dict(param_dict)
>>> print("f32 ld a: %i\nf32 st c: %i\nf64 ld g: %i\nf64 st e: %i" %
... (f32ld_a, f32st_c, f64ld_g, f64st_e))
@@ -1792,12 +1792,12 @@ we'll switch the inner and outer tags in our parallelization of the kernel:
... outer_tag="l.0", inner_tag="l.1")
>>> mem_map = lp.get_mem_access_map(knl_nonconsec, subgroup_size=32)
>>> print(lp.stringify_stats_mapping(mem_map))
- MemAccess(global, np:dtype('float32'), {0: 128, 1: 1}, {}, load, a, workitem) : ...
- MemAccess(global, np:dtype('float32'), {0: 128, 1: 1}, {}, load, b, workitem) : ...
- MemAccess(global, np:dtype('float32'), {0: 128, 1: 1}, {}, store, c, workitem) : ...
- MemAccess(global, np:dtype('float64'), {0: 128, 1: 1}, {}, load, g, workitem) : ...
- MemAccess(global, np:dtype('float64'), {0: 128, 1: 1}, {}, load, h, workitem) : ...
- MemAccess(global, np:dtype('float64'), {0: 128, 1: 1}, {}, store, e, workitem) : ...
+ MemAccess(global, np:dtype('float32'), {0: 128, 1: 1}, {}, load, a, None, workitem) : ...
+ MemAccess(global, np:dtype('float32'), {0: 128, 1: 1}, {}, load, b, None, workitem) : ...
+ MemAccess(global, np:dtype('float32'), {0: 128, 1: 1}, {}, store, c, None, workitem) : ...
+ MemAccess(global, np:dtype('float64'), {0: 128, 1: 1}, {}, load, g, None, workitem) : ...
+ MemAccess(global, np:dtype('float64'), {0: 128, 1: 1}, {}, load, h, None, workitem) : ...
+ MemAccess(global, np:dtype('float64'), {0: 128, 1: 1}, {}, store, e, None, workitem) : ...
<BLANKLINE>
With this parallelization, consecutive work-items will access *nonconsecutive*
@@ -1806,13 +1806,13 @@ changed:
.. doctest::
- >>> f64ld_g = mem_map[lp.MemAccess('global', np.float64, {0: 128, 1: 1}, {}, 'load', 'g', CG.WORKITEM)
+ >>> f64ld_g = mem_map[lp.MemAccess('global', np.float64, {0: 128, 1: 1}, {}, 'load', 'g', None, CG.WORKITEM)
... ].eval_with_dict(param_dict)
- >>> f64st_e = mem_map[lp.MemAccess('global', np.float64, {0: 128, 1: 1}, {}, 'store', 'e', CG.WORKITEM)
+ >>> f64st_e = mem_map[lp.MemAccess('global', np.float64, {0: 128, 1: 1}, {}, 'store', 'e', None, CG.WORKITEM)
... ].eval_with_dict(param_dict)
- >>> f32ld_a = mem_map[lp.MemAccess('global', np.float32, {0: 128, 1: 1}, {}, 'load', 'a', CG.WORKITEM)
+ >>> f32ld_a = mem_map[lp.MemAccess('global', np.float32, {0: 128, 1: 1}, {}, 'load', 'a', None, CG.WORKITEM)
... ].eval_with_dict(param_dict)
- >>> f32st_c = mem_map[lp.MemAccess('global', np.float32, {0: 128, 1: 1}, {}, 'store', 'c', CG.WORKITEM)
+ >>> f32st_c = mem_map[lp.MemAccess('global', np.float32, {0: 128, 1: 1}, {}, 'store', 'c', None, CG.WORKITEM)
... ].eval_with_dict(param_dict)
>>> print("f32 ld a: %i\nf32 st c: %i\nf64 ld g: %i\nf64 st e: %i" %
... (f32ld_a, f32st_c, f64ld_g, f64st_e))
diff --git a/examples/python/hello-loopy.loopy b/examples/python/hello-loopy.loopy
index 0ba44d6eccb18236ac13e17ca747318af3962634..7f79730985119096daf3bbdd31ff17a2c0e7ab2c 100644
--- a/examples/python/hello-loopy.loopy
+++ b/examples/python/hello-loopy.loopy
@@ -1,7 +1,7 @@
# This is a version of hello-loopy.py that can be run through
# a loopy binary using
#
-# ./loopy --lang=loopy hello-loopy-lp.py -
+# ./loopy --lang=loopy hello-loopy.loopy -
knl = lp.make_kernel(
"{ [i]: 0<=i<n }",
diff --git a/loopy/kernel/__init__.py b/loopy/kernel/__init__.py
index 6b0033808c616829e60615b92849fa6353751a82..e3342d0f9d0cac2ef3c4e3d56423ce4b4ba0ac8a 100644
--- a/loopy/kernel/__init__.py
+++ b/loopy/kernel/__init__.py
@@ -142,7 +142,7 @@ class LoopKernel(ImmutableRecordWithoutPickling):
.. note::
This data structure and its attributes should be considered immutable,
- even if it contains mutable data types. See :method:`copy` for an easy
+ even if it contains mutable data types. See :meth:`copy` for an easy
way of producing a modified copy.
.. attribute:: domains
diff --git a/loopy/kernel/array.py b/loopy/kernel/array.py
index 6bf733a84f9df48fbb8433015e1e137f6dc0392c..bae9d7d1fbc873076a84b933e5c78f5c9b19dbb5 100644
--- a/loopy/kernel/array.py
+++ b/loopy/kernel/array.py
@@ -549,15 +549,15 @@ class ArrayBase(ImmutableRecord):
.. attribute :: name
.. attribute :: dtype
- the :class:`loopy.loopytype` of the array.
- if this is *none*, :mod:`loopy` will try to continue without
- knowing the type of this array, where the idea is that precise
- knowledge of the type will become available at invocation time.
- :class:`loopy.compiledkernel` (and thereby
- :meth:`loopy.loopkernel.__call__`) automatically add this type
- information based on invocation arguments.
-
- note that some transformations, such as :func:`loopy.add_padding`
+
+ The :class:`loopy.types.LoopyType` of the array. If this is *None*,
+ :mod:`loopy` will try to continue without knowing the type of this
+ array, where the idea is that precise knowledge of the type will become
+ available at invocation time. Calling the kernel
+ (via :meth:`loopy.LoopKernel.__call__`)
+ automatically adds this type information based on invocation arguments.
+
+ Note that some transformations, such as :func:`loopy.add_padding`
cannot be performed without knowledge of the exact *dtype*.
.. attribute :: shape
diff --git a/loopy/kernel/data.py b/loopy/kernel/data.py
index 3e776bd0609f8c4c6f63aadae811d97a0f97b579..7877f8b939444bf3dc095037ffeaa1bb548c39d6 100644
--- a/loopy/kernel/data.py
+++ b/loopy/kernel/data.py
@@ -49,7 +49,7 @@ from warnings import warn
class auto(object): # noqa
"""A generic placeholder object for something that should be automatically
determined. See, for example, the *shape* or *strides* argument of
- :class:`GlobalArg`.
+ :class:`ArrayArg`.
"""
diff --git a/loopy/statistics.py b/loopy/statistics.py
index 3fecfb778c81ff9db101abca543ae6992e0b3575..9ce2bb081eca67cc6f41864c7ce5965e018ce853 100755
--- a/loopy/statistics.py
+++ b/loopy/statistics.py
@@ -581,6 +581,11 @@ class MemAccess(Record):
A :class:`str` that specifies the variable name of the data
accessed.
+ .. attribute:: variable_tag
+
+ A :class:`str` that specifies the variable tag of a
+ :class:`pymbolic.primitives.TaggedVariable`.
+
.. attribute:: count_granularity
A :class:`str` that specifies whether this operation should be counted
@@ -597,7 +602,8 @@ class MemAccess(Record):
"""
def __init__(self, mtype=None, dtype=None, lid_strides=None, gid_strides=None,
- direction=None, variable=None, count_granularity=None):
+ direction=None, variable=None, variable_tag=None,
+ count_granularity=None):
if count_granularity not in CountGranularity.ALL+[None]:
raise ValueError("Op.__init__: count_granularity '%s' is "
@@ -607,12 +613,14 @@ class MemAccess(Record):
if dtype is None:
Record.__init__(self, mtype=mtype, dtype=dtype, lid_strides=lid_strides,
gid_strides=gid_strides, direction=direction,
- variable=variable, count_granularity=count_granularity)
+ variable=variable, variable_tag=variable_tag,
+ count_granularity=count_granularity)
else:
from loopy.types import to_loopy_type
Record.__init__(self, mtype=mtype, dtype=to_loopy_type(dtype),
lid_strides=lid_strides, gid_strides=gid_strides,
direction=direction, variable=variable,
+ variable_tag=variable_tag,
count_granularity=count_granularity)
def __hash__(self):
@@ -622,7 +630,7 @@ class MemAccess(Record):
def __repr__(self):
# Record.__repr__ overridden for consistent ordering and conciseness
- return "MemAccess(%s, %s, %s, %s, %s, %s, %s)" % (
+ return "MemAccess(%s, %s, %s, %s, %s, %s, %s, %s)" % (
self.mtype,
self.dtype,
None if self.lid_strides is None else dict(
@@ -631,6 +639,7 @@ class MemAccess(Record):
sorted(six.iteritems(self.gid_strides))),
self.direction,
self.variable,
+ self.variable_tag,
self.count_granularity)
# }}}
@@ -697,8 +706,9 @@ class CounterBase(CombineMapper):
# {{{ ExpressionOpCounter
class ExpressionOpCounter(CounterBase):
- def __init__(self, knl):
+ def __init__(self, knl, count_within_subscripts=True):
self.knl = knl
+ self.count_within_subscripts = count_within_subscripts
from loopy.type_inference import TypeInferenceMapper
self.type_inf = TypeInferenceMapper(knl)
@@ -719,7 +729,10 @@ class ExpressionOpCounter(CounterBase):
) + self.rec(expr.parameters)
def map_subscript(self, expr):
- return self.rec(expr.index)
+ if self.count_within_subscripts:
+ return self.rec(expr.index)
+ else:
+ return ToCountMap()
def map_sum(self, expr):
assert expr.children
@@ -981,6 +994,10 @@ class GlobalMemAccessCounter(MemAccessCounter):
def map_subscript(self, expr):
name = expr.aggregate.name
+ try:
+ var_tag = expr.aggregate.tag
+ except AttributeError:
+ var_tag = None
if name in self.knl.arg_dict:
array = self.knl.arg_dict[name]
@@ -1009,6 +1026,7 @@ class GlobalMemAccessCounter(MemAccessCounter):
lid_strides=dict(sorted(six.iteritems(lid_strides))),
gid_strides=dict(sorted(six.iteritems(gid_strides))),
variable=name,
+ variable_tag=var_tag,
count_granularity=count_granularity
): 1}
) + self.rec(expr.index_tuple)
@@ -1314,7 +1332,7 @@ def _get_insn_count(knl, insn_id, subgroup_size, count_redundant_work,
# {{{ get_op_map
def get_op_map(knl, numpy_types=True, count_redundant_work=False,
- subgroup_size=None):
+ count_within_subscripts=True, subgroup_size=None):
"""Count the number of operations in a loopy kernel.
@@ -1330,6 +1348,9 @@ def get_op_map(knl, numpy_types=True, count_redundant_work=False,
(Likely desirable for performance modeling, but undesirable for code
optimization.)
+ :arg count_within_subscripts: A :class:`bool` specifying whether to
+ count operations inside array indices.
+
:arg subgroup_size: (currently unused) An :class:`int`, :class:`str`
``'guess'``, or *None* that specifies the sub-group size. An OpenCL
sub-group is an implementation-dependent grouping of work-items within
@@ -1382,7 +1403,7 @@ def get_op_map(knl, numpy_types=True, count_redundant_work=False,
knl = preprocess_kernel(knl)
op_map = ToCountMap()
- op_counter = ExpressionOpCounter(knl)
+ op_counter = ExpressionOpCounter(knl, count_within_subscripts)
from loopy.kernel.instruction import (
CallInstruction, CInstruction, Assignment,
@@ -1627,6 +1648,7 @@ def get_mem_access_map(knl, numpy_types=True, count_redundant_work=False,
gid_strides=mem_access.gid_strides,
direction=mem_access.direction,
variable=mem_access.variable,
+ variable_tag=mem_access.variable_tag,
count_granularity=mem_access.count_granularity),
ct)
for mem_access, ct in six.iteritems(access_map.count_map)),
diff --git a/loopy/transform/add_barrier.py b/loopy/transform/add_barrier.py
index cfbbd56e906c5e622debcd82bd5368aa3b1fb34c..a20a798cfa35c64c0cbd7097b41824dda2a35a84 100644
--- a/loopy/transform/add_barrier.py
+++ b/loopy/transform/add_barrier.py
@@ -44,15 +44,15 @@ def add_barrier(knl, insn_before="", insn_after="", id_based_on=None,
be any inputs that are understood by :func:`loopy.match.parse_match`.
:arg insn_before: String expression that specifies the instruction(s)
- before the barrier which is to be added
+ before the barrier which is to be added
:arg insn_after: String expression that specifies the instruction(s) after
- the barrier which is to be added
+ the barrier which is to be added
:arg id: String on which the id of the barrier would be based on.
:arg tags: The tag of the group to which the barrier must be added
:arg synchronization_kind: Kind of barrier to be added. May be "global" or
- "local"
+ "local"
:arg kind: Type of memory to be synchronied. May be "global" or "local". Ignored
- for "global" bariers. If not supplied, defaults to :arg:`synchronization_kind`
+ for "global" bariers. If not supplied, defaults to *synchronization_kind*
"""
if mem_kind is None:
diff --git a/loopy/transform/batch.py b/loopy/transform/batch.py
index f0b9814c43698a64af23f1555a27e910ef89762e..f6568918d30f33d4c7103e40d02bdc40c38dfa1b 100644
--- a/loopy/transform/batch.py
+++ b/loopy/transform/batch.py
@@ -106,6 +106,7 @@ def to_batched(knl, nbatches, batch_varying_args, batch_iname_prefix="ibatch",
sequential=False):
"""Takes in a kernel that carries out an operation and returns a kernel
that carries out a batch of these operations.
+
.. note::
For temporaries in a kernel that are private or read only
globals and if `sequential=True`, loopy does not does not batch these
diff --git a/loopy/transform/buffer.py b/loopy/transform/buffer.py
index 801da4c13057edb089d9e9cba098ba41e9919ed6..63d3a40fb6c6967cac5e6149d5cf51bb7c2efbb9 100644
--- a/loopy/transform/buffer.py
+++ b/loopy/transform/buffer.py
@@ -160,7 +160,7 @@ def buffer_array(kernel, var_name, buffer_inames, init_expression=None,
matching contexts. See :func:`loopy.match.parse_stack_match`
for syntax.
:arg temporary_scope: If given, override the choice of
- :class:`AddressSpace` for the created temporary.
+ :class:`AddressSpace` for the created temporary.
:arg default_tag: The default :ref:`iname-tags` to be assigned to the
inames used for fetching and storing
:arg fetch_bounding_box: If the access footprint is non-convex
diff --git a/loopy/transform/iname.py b/loopy/transform/iname.py
index ad1da3e7e67d9d609f51bfed4db7141d14e508dd..83598dcc26646261703ce9b24fecebdd8a975774 100644
--- a/loopy/transform/iname.py
+++ b/loopy/transform/iname.py
@@ -66,8 +66,6 @@ __doc__ = """
.. autofunction:: affine_map_inames
-.. autofunction:: realize_ilp
-
.. autofunction:: find_unused_axis_tag
.. autofunction:: make_reduction_inames_unique
diff --git a/test/test_statistics.py b/test/test_statistics.py
index 3f2366521673597f0cd7e96a22780ffd2c89bdc1..b29edf1ed05f7728b2cbe5b5ad8a74c26944ed8c 100644
--- a/test/test_statistics.py
+++ b/test/test_statistics.py
@@ -57,7 +57,8 @@ def test_op_counter_basic():
knl = lp.add_and_infer_dtypes(knl,
dict(a=np.float32, b=np.float32,
g=np.float64, h=np.float64))
- op_map = lp.get_op_map(knl, subgroup_size=SGS, count_redundant_work=True)
+ op_map = lp.get_op_map(knl, subgroup_size=SGS, count_redundant_work=True,
+ count_within_subscripts=True)
n_workgroups = 1
group_size = 1
subgroups_per_group = div_ceil(group_size, SGS)
@@ -161,7 +162,8 @@ def test_op_counter_specialops():
knl = lp.add_and_infer_dtypes(knl,
dict(a=np.float32, b=np.float32,
g=np.float64, h=np.float64))
- op_map = lp.get_op_map(knl, subgroup_size=SGS, count_redundant_work=True)
+ op_map = lp.get_op_map(knl, subgroup_size=SGS, count_redundant_work=True,
+ count_within_subscripts=True)
n_workgroups = 1
group_size = 1
subgroups_per_group = div_ceil(group_size, SGS)
@@ -206,7 +208,8 @@ def test_op_counter_bitwise():
a=np.int32, b=np.int32,
g=np.int64, h=np.int64))
- op_map = lp.get_op_map(knl, subgroup_size=SGS, count_redundant_work=True)
+ op_map = lp.get_op_map(knl, subgroup_size=SGS, count_redundant_work=True,
+ count_within_subscripts=False)
n_workgroups = 1
group_size = 1
subgroups_per_group = div_ceil(group_size, SGS)
@@ -226,7 +229,7 @@ def test_op_counter_bitwise():
i64shift = op_map[lp.Op(np.dtype(np.int64), 'shift', CG.SUBGROUP)
].eval_with_dict(params)
# (count-per-sub-group)*n_subgroups
- assert i32add == n*m+n*m*ell*n_subgroups
+ assert i32add == n*m*ell*n_subgroups
assert i32bw == 2*n*m*ell*n_subgroups
assert i64bw == 2*n*m*n_subgroups
assert i64add == i64mul == n*m*n_subgroups
@@ -1057,6 +1060,65 @@ def test_all_counters_parallel_matmul():
assert local_mem_s == m*2/bsize*n_subgroups
+def test_mem_access_tagged_variables():
+ bsize = 16
+ knl = lp.make_kernel(
+ "{[i,k,j]: 0<=i<n and 0<=k<m and 0<=j<ell}",
+ [
+ "c$mmresult[i, j] = sum(k, a$mmaload[i, k]*b$mmbload[k, j])"
+ ],
+ name="matmul", assumptions="n,m,ell >= 1")
+ knl = lp.add_and_infer_dtypes(knl, dict(a=np.float32, b=np.float32))
+ knl = lp.split_iname(knl, "i", bsize, outer_tag="g.0", inner_tag="l.1")
+ knl = lp.split_iname(knl, "j", bsize, outer_tag="g.1", inner_tag="l.0")
+ knl = lp.split_iname(knl, "k", bsize)
+ # knl = lp.add_prefetch(knl, "a", ["k_inner", "i_inner"], default_tag="l.auto")
+ # knl = lp.add_prefetch(knl, "b", ["j_inner", "k_inner"], default_tag="l.auto")
+
+ n = 512
+ m = 256
+ ell = 128
+ params = {'n': n, 'm': m, 'ell': ell}
+ group_size = bsize*bsize
+ n_workgroups = div_ceil(n, bsize)*div_ceil(ell, bsize)
+ subgroups_per_group = div_ceil(group_size, SGS)
+ n_subgroups = n_workgroups*subgroups_per_group
+
+ mem_access_map = lp.get_mem_access_map(knl, count_redundant_work=True,
+ subgroup_size=SGS)
+
+ f32s1lb = mem_access_map[lp.MemAccess('global', np.float32,
+ lid_strides={0: 1},
+ gid_strides={1: bsize},
+ direction='load', variable='b',
+ variable_tag='mmbload',
+ count_granularity=CG.WORKITEM)
+ ].eval_with_dict(params)
+ f32s1la = mem_access_map[lp.MemAccess('global', np.float32,
+ lid_strides={1: Variable('m')},
+ gid_strides={0: Variable('m')*bsize},
+ direction='load',
+ variable='a',
+ variable_tag='mmaload',
+ count_granularity=CG.SUBGROUP)
+ ].eval_with_dict(params)
+
+ assert f32s1lb == n*m*ell
+
+ # uniform: (count-per-sub-group)*n_subgroups
+ assert f32s1la == m*n_subgroups
+
+ f32coal = mem_access_map[lp.MemAccess('global', np.float32,
+ lid_strides={0: 1, 1: Variable('ell')},
+ gid_strides={0: Variable('ell')*bsize, 1: bsize},
+ direction='store', variable='c',
+ variable_tag='mmresult',
+ count_granularity=CG.WORKITEM)
+ ].eval_with_dict(params)
+
+ assert f32coal == n*ell
+
+
def test_gather_access_footprint():
knl = lp.make_kernel(
"{[i,k,j]: 0<=i,j,k<n}",
@@ -1153,7 +1215,8 @@ def test_summations_and_filters():
assert f32lall == (3*n*m*ell)*n_subgroups
assert f64lall == (2*n*m)*n_subgroups
- op_map = lp.get_op_map(knl, subgroup_size=SGS, count_redundant_work=True)
+ op_map = lp.get_op_map(knl, subgroup_size=SGS, count_redundant_work=True,
+ count_within_subscripts=True)
#for k, v in op_map.items():
# print(type(k), "\n", k.name, k.dtype, type(k.dtype), " :\n", v)