def _parse_memlet_from_str(self, expr: str):
"""
Parses a memlet and fills in either the src_subset,dst_subset fields
or the _data,_subset fields.
:param expr: A string expression of the this memlet, given as an ease
of use API. Must follow one of the following forms:
1. ``ARRAY``,
2. ``ARRAY[SUBSET]``,
3. ``ARRAY[SUBSET] -> OTHER_SUBSET``.
Note that modes 2 and 3 are deprecated and will leave
the memlet uninitialized until inserted into an SDFG.
"""
expr = expr.strip()
if '->' not in expr: # Options 1 and 2
self.data, self.subset = self._parse_from_subexpr(expr)
return
# Option 3
src_expr, dst_expr = expr.split('->')
src_expr = src_expr.strip()
dst_expr = dst_expr.strip()
if '[' not in src_expr and not dtypes.validate_name(src_expr):
raise SyntaxError('Expression without data name not yet allowed')
self.data, self.subset = self._parse_from_subexpr(src_expr)
self.other_subset = SubsetProperty.from_string(dst_expr)
def _parse_from_subexpr(self, expr: str):
if expr[-1] != ']': # No subset given, try to use whole array
if not dtypes.validate_name(expr):
raise SyntaxError('Invalid memlet syntax "%s"' % expr)
return expr, None
# array[subset] syntax
arrname, subset_str = expr[:-1].split('[')
if not dtypes.validate_name(arrname):
raise SyntaxError('Invalid array name "%s" in memlet' % arrname)
return arrname, SubsetProperty.from_string(subset_str)
def simple(data,
subset_str,
veclen=1,
wcr_str=None,
wcr_identity=None,
other_subset_str=None,
wcr_conflict=True,
num_accesses=None,
debuginfo=None):
""" Constructs a Memlet from string-based expressions.
@param data: The data object or name to access. B{Note:} this
parameter will soon be deprecated.
@type data: Either a string of the data descriptor name or an
AccessNode.
@param subset_str: The subset of `data` that is going to
be accessed in string format. Example: '0:N'.
@param veclen: The length of a single unit of access to
the data (used for vectorization optimizations).
@param wcr_str: A lambda function (as a string) specifying
how write-conflicts are resolved. The syntax
of the lambda function receives two elements:
`current` value and `new` value,
and returns the value after resolution. For
example, summation is
`'lambda cur, new: cur + new'`.
@param wcr_identity: Identity value used for the first write
conflict. B{Note:} this parameter will soon
be deprecated.
@param other_subset_str: The reindexing of `subset` on the other
connected data (as a string).
@param wcr_conflict: If False, forces non-locked conflict
resolution when generating code. The default
is to let the code generator infer this
information from the SDFG.
@param num_accesses: The number of times that the moved data
will be subsequently accessed. If
`dace.types.DYNAMIC` (-1),
designates that the number of accesses is
unknown at compile time.
@param debuginfo: Source-code information (e.g., line, file)
used for debugging.
"""
subset = SubsetProperty.from_string(subset_str)
if num_accesses is not None:
na = num_accesses
else:
na = subset.num_elements()
if wcr_str is not None:
wcr = LambdaProperty.from_string(wcr_str)
else:
wcr = None
if other_subset_str is not None:
other_subset = SubsetProperty.from_string(other_subset_str)
else:
other_subset = None
# If it is an access node or another memlet
if hasattr(data, 'data'):
data = data.data
return Memlet(data,
na,
subset,
veclen,
wcr=wcr,
wcr_identity=wcr_identity,
other_subset=other_subset,
wcr_conflict=wcr_conflict,
debuginfo=debuginfo)
def simple(data,
subset_str,
wcr_str=None,
other_subset_str=None,
wcr_conflict=True,
num_accesses=None,
debuginfo=None,
dynamic=False):
""" DEPRECATED: Constructs a Memlet from string-based expressions.
:param data: The data object or name to access.
:type data: Either a string of the data descriptor name or an
AccessNode.
:param subset_str: The subset of `data` that is going to
be accessed in string format. Example: '0:N'.
:param wcr_str: A lambda function (as a string) specifying
how write-conflicts are resolved. The syntax
of the lambda function receives two elements:
`current` value and `new` value,
and returns the value after resolution. For
example, summation is
`'lambda cur, new: cur + new'`.
:param other_subset_str: The reindexing of `subset` on the other
connected data (as a string).
:param wcr_conflict: If False, forces non-locked conflict
resolution when generating code. The default
is to let the code generator infer this
information from the SDFG.
:param num_accesses: The number of times that the moved data
will be subsequently accessed. If
-1, designates that the number of accesses is
unknown at compile time.
:param debuginfo: Source-code information (e.g., line, file)
used for debugging.
:param dynamic: If True, the number of elements moved in this memlet
is defined dynamically at runtime.
"""
# warnings.warn(
# 'This function is deprecated, please use the Memlet '
# 'constructor instead', DeprecationWarning)
result = Memlet()
if isinstance(subset_str, subsets.Subset):
result.subset = subset_str
else:
result.subset = SubsetProperty.from_string(subset_str)
result.dynamic = dynamic
if num_accesses is not None:
if num_accesses == -1:
result.dynamic = True
result.volume = 0
else:
result.volume = num_accesses
else:
result.volume = result._subset.num_elements()
if wcr_str is not None:
if isinstance(wcr_str, ast.AST):
result.wcr = wcr_str
else:
result.wcr = LambdaProperty.from_string(wcr_str)
if other_subset_str is not None:
if isinstance(other_subset_str, subsets.Subset):
result.other_subset = other_subset_str
else:
result.other_subset = SubsetProperty.from_string(
other_subset_str)
else:
result.other_subset = None
# If it is an access node or another memlet
if hasattr(data, 'data'):
result.data = data.data
else:
result.data = data
result.wcr_nonatomic = not wcr_conflict
return result