def _globalify(value):
data = np.array(value, dtype=np.float64)
shape = data.shape
rank = len(shape)
if rank == 0:
dat = op2.Global(1, data)
elif rank == 1:
dat = op2.Global(shape, data)
elif rank == 2:
dat = op2.Global(shape, data)
else:
raise RuntimeError(
"Don't know how to make Constant from data with rank %d" % rank)
return dat, rank, shape
def test_change_global_dtype_matters(self, iterset, diterset):
g = op2.Global(1, 0, dtype=numpy.uint32)
self.cache.clear()
assert len(self.cache) == 0
k = op2.Kernel("""static void k(void *x) {}""", 'k')
op2.par_loop(k, iterset, g(op2.INC))
assert len(self.cache) == 1
g = op2.Global(1, 0, dtype=numpy.float64)
op2.par_loop(k, iterset, g(op2.INC))
assert len(self.cache) == 2
def test_1d_inc_no_data(self, k1_inc_to_global, set, d1):
g = op2.Global(1, dtype=numpy.uint32)
op2.par_loop(k1_inc_to_global, set,
g(op2.INC),
d1(op2.READ))
assert g.data == d1.data.sum()
def test_2d_read(self, k2_write_to_dat, set, d1):
g = op2.Global(2, (1, 2), dtype=numpy.uint32)
op2.par_loop(k2_write_to_dat, set,
d1(op2.WRITE),
g(op2.READ))
assert all(d1.data == g.data.sum())
def test_1d_read(self, k1_write_to_dat, set, d1):
g = op2.Global(1, 1, dtype=numpy.uint32)
op2.par_loop(k1_write_to_dat, set,
d1(op2.WRITE),
g(op2.READ))
assert all(d1.data == g.data)
def test_1d_read_no_init(self, k1_write_to_dat, set, d1):
g = op2.Global(1, dtype=numpy.uint32)
d1.data[:] = 100
op2.par_loop(k1_write_to_dat, set, d1(op2.WRITE), g(op2.READ))
assert all(g.data == 0)
assert all(d1.data == 0)
def setupData(poses, constraints, vertices=V, edges=E):
""" setting up Dat objects from the loaded vertex and edge DataFrames
0) x is the Dat of pose parameters we are optimizing
1) err is the large vector of measurement errors
2) estimate is the estimate we will calculate based on parameters
3) measurement is the actual measurement between vertices
4) jacobian blocks are used to build rhs_vec and hessian
5) omega_blocks is a static quantity from the edges DataFrame
6) rhs_vec will hold the vector of values for the NLS equation
7) sse is sum of squares we use to evaluate convergence
"""
err = op2.Dat(dataset=constraints ** CONSTRAINT_DIM,
data=None,
dtype=np.float64,
name='e')
estimate = op2.Dat(dataset=constraints ** CONSTRAINT_DIM,
data=None,
dtype=np.float64,
name='estimate')
pose_slice = ['dim%d' % i for i in xrange(1, POSES_DIM + 1)]
x = op2.Dat(dataset=poses ** POSES_DIM,
data=vertices[pose_slice].values.reshape(POSES_DIM, NUM_POSES),
dtype=np.float64,
name='x')
if _DEBUG:
print '-' * 80
print 'ba vertices:'
vertex_data = vertices[pose_slice].values
print vertex_data
print vertex_data.shape
meas_slice = ['meas%d' % i for i in xrange(1, CONSTRAINT_DIM + 1)]
measurement = op2.Dat(dataset=constraints ** CONSTRAINT_DIM,
data=edges[meas_slice].values.reshape(CONSTRAINT_DIM, NUM_CONSTRAINTS),
dtype=np.float64,
name='measurement')
jacobian_blocks = op2.Dat(dataset=constraints ** (CONSTRAINT_DIM * POSES_DIM * POSES_PER_CONSTRAINT),
data=None,
dtype=np.float64,
name='jacobian_blocks')
omega_slice = ['meas%d' % i for i in xrange(CONSTRAINT_DIM + 1,
CONSTRAINT_DIM + OMEGA_DOF + 1)]
omega_blocks = op2.Dat(dataset=constraints ** OMEGA_DOF,
data=edges[omega_slice].values.reshape(OMEGA_DOF, NUM_CONSTRAINTS),
dtype=np.float64,
name='omega_blocks')
rhs_vec = op2.Dat(poses ** POSES_DIM, dtype=np.float64, name='rhs_vec')
dx = op2.Dat(dataset=poses ** POSES_DIM, dtype=np.float64, name='dx')
# scalar value which is the sum-of-squares calcuation
sse = op2.Global(dim=1, data=[0.0], dtype=np.float64)
sse_arr = op2.Dat(dataset=constraints ** 1, dtype=np.float64, name='array')
return (err, x, estimate, measurement, jacobian_blocks, omega_blocks,
rhs_vec, dx, sse, sse_arr)
def test_1d_max_global_is_max(self, k1_max_to_global, set, d1):
val = d1.data.max() + 1
g = op2.Global(1, val, dtype=numpy.uint32)
op2.par_loop(k1_max_to_global, set,
g(op2.MAX),
d1(op2.READ))
assert g.data == val
def test_1d_min_global_is_min(self, k1_min_to_global, set, d1):
d1.data[:] += 10
val = d1.data.min() - 1
g = op2.Global(1, val, dtype=numpy.uint32)
op2.par_loop(k1_min_to_global, set,
g(op2.MIN),
d1(op2.READ))
assert g.data == val
def test_change_global_dtype_matters(self, backend, iterset, diterset):
g = op2.Global(1, 0, dtype=numpy.uint32)
self.cache.clear()
assert len(self.cache) == 0
k = op2.Kernel("""void k(void *x) {}""", 'k')
op2.par_loop(k, iterset, g(op2.INC))
op2.base._trace.evaluate(set([g]), set())
assert len(self.cache) == 1
g = op2.Global(1, 0, dtype=numpy.float64)
op2.par_loop(k, iterset, g(op2.INC))
op2.base._trace.evaluate(set([g]), set())
assert len(self.cache) == 2
def test_2d_max_dat_is_max(self, backend, k2_max_to_global, set, d2):
val_0 = d2.data[:, 0].max() - 1
val_1 = d2.data[:, 1].max() - 1
g = op2.Global(2, (val_0, val_1), dtype=numpy.uint32)
op2.par_loop(k2_max_to_global, set, d2(op2.READ), g(op2.MAX))
assert g.data[0] == d2.data[:, 0].max()
assert g.data[1] == d2.data[:, 1].max()
def test_1d_multi_inc_same_global(self, k1_inc_to_global, set, d1):
g = op2.Global(1, 0, dtype=numpy.uint32)
op2.par_loop(k1_inc_to_global, set, d1(op2.READ), g(op2.INC))
assert g.data == d1.data.sum()
op2.par_loop(k1_inc_to_global, set, d1(op2.READ), g(op2.INC))
assert g.data == d1.data.sum() * 2
def test_1d_min_dat_is_min(self, k1_min_to_global, set, d1):
val = d1.data.min() + 1
g = op2.Global(1, val, dtype=numpy.uint32)
op2.par_loop(k1_min_to_global, set,
d1(op2.READ),
g(op2.MIN))
assert g.data == d1.data.min()
def test_2d_inc(self, k2_inc_to_global, set, d2):
g = op2.Global(2, (0, 0), dtype=numpy.uint32)
op2.par_loop(k2_inc_to_global, set,
g(op2.INC),
d2(op2.READ))
assert g.data[0] == d2.data[:, 0].sum()
assert g.data[1] == d2.data[:, 1].sum()
def test_2d_min_dat_is_min(self, k2_min_to_global, set, d2):
val_0 = d2.data[:, 0].min() + 1
val_1 = d2.data[:, 1].min() + 1
g = op2.Global(2, (val_0, val_1), dtype=numpy.uint32)
op2.par_loop(k2_min_to_global, set, d2(op2.READ), g(op2.MIN))
assert g.data[0] == d2.data[:, 0].min()
assert g.data[1] == d2.data[:, 1].min()
def test_2d_max_global_is_max(self, k2_max_to_global, set, d2):
max_val_0 = d2.data[:, 0].max() + 1
max_val_1 = d2.data[:, 1].max() + 1
g = op2.Global(2, (max_val_0, max_val_1), dtype=numpy.uint32)
op2.par_loop(k2_max_to_global, set, d2(op2.READ), g(op2.MAX))
assert g.data[0] == max_val_0
assert g.data[1] == max_val_1
def test_2d_min_global_is_min(self, backend, k2_min_to_global, set, d2):
d2.data[:, 0] += 10
d2.data[:, 1] += 10
val_0 = d2.data[:, 0].min() - 1
val_1 = d2.data[:, 1].min() - 1
g = op2.Global(2, (val_0, val_1), dtype=numpy.uint32)
op2.par_loop(k2_min_to_global, set, d2(op2.READ), g(op2.MIN))
assert g.data[0] == val_0
assert g.data[1] == val_1
def test_global_read(self, iterset, x, iterset2indset):
"""Divide a Dat by a Global."""
g = op2.Global(1, 2, np.uint32, "g")
kernel_global_read = "void kernel_global_read(unsigned int* x, unsigned int* g) { (*x) /= (*g); }\n"
op2.par_loop(op2.Kernel(kernel_global_read, "kernel_global_read"),
iterset, x(op2.RW, iterset2indset[0]), g(op2.READ))
assert sum(x.data) == sum(map(lambda v: v // 2, range(nelems)))
def test_reorder(self, skip_greedy, iterset):
a = op2.Global(1, 0, numpy.uint32, "a")
b = op2.Global(1, 0, numpy.uint32, "b")
kernel = """
static void count(unsigned int* x)
{
(*x) += 1;
}
"""
op2.par_loop(op2.Kernel(kernel, "count"), iterset, a(op2.INC))
op2.par_loop(op2.Kernel(kernel, "count"), iterset, b(op2.INC))
assert a._data[0] == 0
assert b._data[0] == 0
assert b.data[0] == nelems
assert a._data[0] == 0
assert a.data[0] == nelems
def test_inc_repeated_loop(self, set):
g = op2.Global(1, 0, dtype=numpy.uint32)
k = """void k(unsigned int* g) { *g += 1; }"""
op2.par_loop(op2.Kernel(k, "k"), set, g(op2.INC))
assert_allclose(g.data, set.size)
op2.par_loop(op2.Kernel(k, "k"), set, g(op2.INC))
assert_allclose(g.data, 2 * set.size)
g.zero()
op2.par_loop(op2.Kernel(k, "k"), set, g(op2.INC))
assert_allclose(g.data, set.size)
def test_direct_min_uint32(self, backend, set, duint32):
kernel_min = """
void kernel_min(unsigned int* x, unsigned int* g)
{
if ( *x < *g ) *g = *x;
}
"""
g = op2.Global(1, 8, numpy.uint32, "g")
op2.par_loop(op2.Kernel(kernel_min, "kernel_min"), set,
duint32(op2.READ), g(op2.MIN))
assert g.data[0] == 8
def test_direct_min_int32(self, set, dint32):
kernel_min = """
void kernel_min(int* x, int* g)
{
if ( *x < *g ) *g = *x;
}
"""
g = op2.Global(1, 8, numpy.int32, "g")
op2.par_loop(op2.Kernel(kernel_min, "kernel_min"), set,
dint32(op2.READ), g(op2.MIN))
assert g.data[0] == -12
def test_direct_max_float(self, backend, set, dfloat32):
kernel_max = """
void kernel_max(float* x, float* g)
{
if ( *x > *g ) *g = *x;
}
"""
g = op2.Global(1, -42.8, numpy.float32, "g")
op2.par_loop(op2.Kernel(kernel_max, "kernel_max"), set,
dfloat32(op2.READ), g(op2.MAX))
assert_allclose(g.data[0], -12.0)
def test_direct_max_double(self, set, dfloat64):
kernel_max = """
void kernel_max(double* x, double* g)
{
if ( *x > *g ) *g = *x;
}
"""
g = op2.Global(1, -42.8, numpy.float64, "g")
op2.par_loop(op2.Kernel(kernel_max, "kernel_max"), set,
dfloat64(op2.READ), g(op2.MAX))
assert_allclose(g.data[0], -12.0)
def test_direct_min_double(self, set, dfloat64):
kernel_min = """
void kernel_min(double* x, double* g)
{
if ( *x < *g ) *g = *x;
}
"""
g = op2.Global(1, -.8, numpy.float64, "g")
op2.par_loop(op2.Kernel(kernel_min, "kernel_min"), set,
dfloat64(op2.READ), g(op2.MIN))
assert_allclose(g.data[0], -12.0)
def test_direct_max_int32(self, set, dint32):
kernel_max = """
void kernel_max(int* x, int* g)
{
if ( *x > *g ) *g = *x;
}
"""
g = op2.Global(1, -42, numpy.int32, "g")
op2.par_loop(op2.Kernel(kernel_max, "kernel_max"), set,
dint32(op2.READ), g(op2.MAX))
assert g.data[0] == -12
def test_chain(self, skip_greedy, iterset):
a = op2.Global(1, 0, numpy.uint32, "a")
x = op2.Dat(iterset, numpy.zeros(nelems), numpy.uint32, "x")
y = op2.Dat(iterset, numpy.zeros(nelems), numpy.uint32, "y")
kernel_add_one = """
void
add_one(unsigned int* x)
{
(*x) += 1;
}
"""
kernel_copy = """
void
copy(unsigned int* dst, unsigned int* src)
{
(*dst) = (*src);
}
"""
kernel_sum = """
void
sum(unsigned int* sum, unsigned int* x)
{
(*sum) += (*x);
}
"""
pl_add = op2.par_loop(op2.Kernel(kernel_add_one, "add_one"), iterset,
x(op2.RW))
pl_copy = op2.par_loop(op2.Kernel(kernel_copy, "copy"), iterset,
y(op2.WRITE), x(op2.READ))
pl_sum = op2.par_loop(op2.Kernel(kernel_sum, "sum"), iterset,
a(op2.INC), x(op2.READ))
# check everything is zero at first
assert sum(x._data) == 0
assert sum(y._data) == 0
assert a._data[0] == 0
assert base._trace.in_queue(pl_add)
assert base._trace.in_queue(pl_copy)
assert base._trace.in_queue(pl_sum)
# force computation affecting 'a' (1st and 3rd par_loop)
assert a.data[0] == nelems
assert not base._trace.in_queue(pl_add)
assert base._trace.in_queue(pl_copy)
assert not base._trace.in_queue(pl_sum)
assert sum(x.data) == nelems
# force the last par_loop remaining (2nd)
assert sum(y.data) == nelems
assert not base._trace.in_queue(pl_copy)
def test_inc_reused_loop(self, set):
from pyop2.base import collecting_loops
g = op2.Global(1, 0, dtype=numpy.uint32)
k = """void k(unsigned int* g) { *g += 1; }"""
with collecting_loops(True):
loop = op2.par_loop(op2.Kernel(k, "k"), set, g(op2.INC))
loop()
assert_allclose(g.data, set.size)
loop()
assert_allclose(g.data, 2 * set.size)
g.zero()
loop()
assert_allclose(g.data, set.size)
def test_direct_min_uint32(self, set, duint32):
kernel_min = """
static void k(unsigned int* g, unsigned int* x)
{
if ( *x < *g ) *g = *x;
}
"""
g = op2.Global(1, 8, numpy.uint32, "g")
op2.par_loop(op2.Kernel(kernel_min, "k"), set,
g(op2.MIN),
duint32(op2.READ))
assert g.data[0] == 8
def test_global_inc(self, iterset, x, iterset2indset):
"""Increment each value of a Dat by one and a Global at the same time."""
g = op2.Global(1, 0, np.uint32, "g")
kernel_global_inc = """
void kernel_global_inc(unsigned int *x, unsigned int *inc) {
(*x) = (*x) + 1; (*inc) += (*x);
}"""
op2.par_loop(op2.Kernel(kernel_global_inc, "kernel_global_inc"),
iterset, x(op2.RW, iterset2indset[0]), g(op2.INC))
assert sum(x.data) == nelems * (nelems + 1) // 2
assert g.data[0] == nelems * (nelems + 1) // 2
