def test_create_ops_arg_function(self, read):
u = OpsAccessible('u', dtype=np.float32, read_only=read)
dat = OpsDat('u_dat')
stencil = OpsStencil('stencil')
info = AccessibleInfo(u, None, None)
ops_arg = create_ops_arg(u, {'u': info}, {'u': dat}, {u: stencil})
assert ops_arg.ops_type == namespace['ops_arg_dat']
assert ops_arg.ops_name == OpsDat('u_dat')
assert ops_arg.elements_per_point == 1
assert ops_arg.dtype == Literal('"%s"' % dtype_to_cstr(u.dtype))
assert ops_arg.rw_flag == \
namespace['ops_read'] if read else namespace['ops_write']
def test_create_ops_arg_function(self, read):
u = OpsAccessible('u', np.float32, read)
dat = OpsDat('u_dat')
stencil = OpsStencil('stencil')
info = AccessibleInfo(u, None, None)
res = create_ops_arg(u, {'u': info}, {'u': dat}, {u: stencil})
assert type(res) == namespace['ops_arg_dat']
assert res.args == (dat, 1, stencil,
Literal('"%s"' % dtype_to_cstr(u.dtype)),
namespace['ops_read']
if read else namespace['ops_write'])
def create_ops_dat(f, name_to_ops_dat, block):
ndim = f.ndim - (1 if f.is_TimeFunction else 0)
dim = Array(name=namespace['ops_dat_dim'](f.name),
dimensions=(DefaultDimension(name='dim',
default_value=ndim), ),
dtype=np.int32,
scope='stack')
base = Array(name=namespace['ops_dat_base'](f.name),
dimensions=(DefaultDimension(name='base',
default_value=ndim), ),
dtype=np.int32,
scope='stack')
d_p = Array(name=namespace['ops_dat_d_p'](f.name),
dimensions=(DefaultDimension(name='d_p',
default_value=ndim), ),
dtype=np.int32,
scope='stack')
d_m = Array(name=namespace['ops_dat_d_m'](f.name),
dimensions=(DefaultDimension(name='d_m',
default_value=ndim), ),
dtype=np.int32,
scope='stack')
base_val = [Zero() for i in range(ndim)]
# If f is a TimeFunction we need to create a ops_dat for each time stepping
# variable (eg: t1, t2)
if f.is_TimeFunction:
time_pos = f._time_position
time_index = f.indices[time_pos]
time_dims = f.shape[time_pos]
dim_val = f.shape[:time_pos] + f.shape[time_pos + 1:]
d_p_val = f._size_nodomain.left[time_pos + 1:]
d_m_val = [-i for i in f._size_nodomain.right[time_pos + 1:]]
ops_dat_array = Array(name=namespace['ops_dat_name'](f.name),
dimensions=(DefaultDimension(
name='dat', default_value=time_dims), ),
dtype=namespace['ops_dat_type'],
scope='stack')
dat_decls = []
for i in range(time_dims):
name = '%s%s%s' % (f.name, time_index, i)
dat_decls.append(namespace['ops_decl_dat'](block, 1,
Symbol(dim.name),
Symbol(base.name),
Symbol(d_m.name),
Symbol(d_p.name),
Byref(f.indexify([i])),
Literal('"%s"' %
f._C_typedata),
Literal('"%s"' % name)))
ops_decl_dat = Expression(
ClusterizedEq(Eq(ops_dat_array, ListInitializer(dat_decls))))
# Inserting the ops_dat array in case of TimeFunction.
name_to_ops_dat[f.name] = ops_dat_array
else:
ops_dat = OpsDat("%s_dat" % f.name)
name_to_ops_dat[f.name] = ops_dat
dim_val = f.shape
d_p_val = f._size_nodomain.left
d_m_val = [-i for i in f._size_nodomain.right]
ops_decl_dat = Expression(
ClusterizedEq(
Eq(
ops_dat,
namespace['ops_decl_dat'](block, 1, Symbol(dim.name),
Symbol(base.name),
Symbol(d_m.name),
Symbol(d_p.name),
Byref(f.indexify([0])),
Literal('"%s"' % f._C_typedata),
Literal('"%s"' % f.name)))))
dim_val = Expression(ClusterizedEq(Eq(dim, ListInitializer(dim_val))))
base_val = Expression(ClusterizedEq(Eq(base, ListInitializer(base_val))))
d_p_val = Expression(ClusterizedEq(Eq(d_p, ListInitializer(d_p_val))))
d_m_val = Expression(ClusterizedEq(Eq(d_m, ListInitializer(d_m_val))))
return OpsDatDecl(dim_val=dim_val,
base_val=base_val,
d_p_val=d_p_val,
d_m_val=d_m_val,
ops_decl_dat=ops_decl_dat)
def create_ops_dat(f, name_to_ops_dat, block):
ndim = f.ndim - (1 if f.is_TimeFunction else 0)
dim = Array(name=namespace['ops_dat_dim'](f.name),
dimensions=(DefaultDimension(name='dim',
default_value=ndim), ),
dtype=np.int32,
scope='stack')
base = Array(name=namespace['ops_dat_base'](f.name),
dimensions=(DefaultDimension(name='base',
default_value=ndim), ),
dtype=np.int32,
scope='stack')
d_p = Array(name=namespace['ops_dat_d_p'](f.name),
dimensions=(DefaultDimension(name='d_p',
default_value=ndim), ),
dtype=np.int32,
scope='stack')
d_m = Array(name=namespace['ops_dat_d_m'](f.name),
dimensions=(DefaultDimension(name='d_m',
default_value=ndim), ),
dtype=np.int32,
scope='stack')
res = []
base_val = [Zero() for i in range(ndim)]
# If f is a TimeFunction we need to create a ops_dat for each time stepping
# variable (eg: t1, t2)
if f.is_TimeFunction:
time_pos = f._time_position
time_index = f.indices[time_pos]
time_dims = f.shape[time_pos]
dim_shape = sympify(f.shape[:time_pos] + f.shape[time_pos + 1:])
padding = f.padding[:time_pos] + f.padding[time_pos + 1:]
halo = f.halo[:time_pos] + f.halo[time_pos + 1:]
d_p_val = tuple(sympify([p[0] + h[0] for p, h in zip(padding, halo)]))
d_m_val = tuple(
sympify([-(p[1] + h[1]) for p, h in zip(padding, halo)]))
ops_dat_array = Array(name=namespace['ops_dat_name'](f.name),
dimensions=(DefaultDimension(
name='dat', default_value=time_dims), ),
dtype='ops_dat',
scope='stack')
dat_decls = []
for i in range(time_dims):
name = '%s%s%s' % (f.name, time_index, i)
name_to_ops_dat[name] = ops_dat_array.indexify(
[Symbol('%s%s' % (time_index, i))])
dat_decls.append(namespace['ops_decl_dat'](block, 1,
Symbol(dim.name),
Symbol(base.name),
Symbol(d_m.name),
Symbol(d_p.name),
Byref(f.indexify([i])),
Literal('"%s"' %
f._C_typedata),
Literal('"%s"' % name)))
ops_decl_dat = Expression(
ClusterizedEq(Eq(ops_dat_array, ListInitializer(dat_decls))))
else:
ops_dat = OpsDat("%s_dat" % f.name)
name_to_ops_dat[f.name] = ops_dat
d_p_val = tuple(
sympify([p[0] + h[0] for p, h in zip(f.padding, f.halo)]))
d_m_val = tuple(
sympify([-(p[1] + h[1]) for p, h in zip(f.padding, f.halo)]))
dim_shape = sympify(f.shape)
ops_decl_dat = Expression(
ClusterizedEq(
Eq(
ops_dat,
namespace['ops_decl_dat'](block, 1, Symbol(dim.name),
Symbol(base.name),
Symbol(d_m.name),
Symbol(d_p.name),
Byref(f.indexify([0])),
Literal('"%s"' % f._C_typedata),
Literal('"%s"' % f.name)))))
res.append(Expression(ClusterizedEq(Eq(dim, ListInitializer(dim_shape)))))
res.append(Expression(ClusterizedEq(Eq(base, ListInitializer(base_val)))))
res.append(Expression(ClusterizedEq(Eq(d_p, ListInitializer(d_p_val)))))
res.append(Expression(ClusterizedEq(Eq(d_m, ListInitializer(d_m_val)))))
res.append(ops_decl_dat)
return res