From 7a833eb6f4ff141c771666dc492e5cc68e5216dc Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Keck <Jean-Baptiste.Keck@imag.fr>
Date: Sun, 24 Feb 2019 22:30:04 +0100
Subject: [PATCH] working opencl compute_energy kernel (non optimized)
---
ci/scripts/test.sh | 33 ++---
hysop/backend/device/codegen/base/codegen.py | 2 +-
.../kernels/custom_symbolic_affect.py | 70 ++++++-----
hysop/backend/device/codegen/symbolic/map.py | 2 -
hysop/numerics/fft/host_fft.py | 4 +-
hysop/numerics/fft/opencl_fft.py | 7 +-
.../operator/base/custom_symbolic_operator.py | 118 +++++++++++-------
hysop/parameters/tensor_parameter.py | 6 +-
hysop/symbolic/complex.py | 2 +-
hysop/symbolic/misc.py | 50 +++++---
test_examples.sh | 1 +
11 files changed, 171 insertions(+), 124 deletions(-)
diff --git a/ci/scripts/test.sh b/ci/scripts/test.sh
index 51b8b970e..cd8f4330f 100755
--- a/ci/scripts/test.sh
+++ b/ci/scripts/test.sh
@@ -76,22 +76,23 @@ python "$HYSOP_DIR/operator/tests/test_poisson_curl.py"
python -c "from hysop.f2hysop import scales2py as scales" && python "$HYSOP_DIR/operator/tests/test_scales_advection.py"
python -c "from hysop.f2hysop import scales2py as scales" && python "$HYSOP_DIR/operator/tests/test_bilevel_advection.py"
-#export HYSOP_VERBOSE=1
-#EXAMPLE_DIR="$HYSOP_DIR/../examples"
-#EXAMPLE_OPTIONS='-cp default -maxit 2'
-#python "$EXAMPLE_DIR/analytic/analytic.py" $EXAMPLE_OPTIONS
-#python "$EXAMPLE_DIR/scalar_diffusion/scalar_diffusion.py" $EXAMPLE_OPTIONS
-#python "$EXAMPLE_DIR/scalar_advection/scalar_advection.py" $EXAMPLE_OPTIONS
-#python "$EXAMPLE_DIR/shear_layer/shear_layer.py" $EXAMPLE_OPTIONS
-#python "$EXAMPLE_DIR/taylor_green/taylor_green.py" -impl python $EXAMPLE_OPTIONS
-#python "$EXAMPLE_DIR/taylor_green/taylor_green.py" -impl opencl $EXAMPLE_OPTIONS
-#python -c "from hysop.f2hysop import scales2py as scales" && python "$EXAMPLE_DIR/taylor_green/taylor_green.py" -impl fortran $EXAMPLE_OPTIONS
-#python "$EXAMPLE_DIR/bubble/periodic_bubble.py" $EXAMPLE_OPTIONS
-#python "$EXAMPLE_DIR/bubble/periodic_bubble_levelset.py" $EXAMPLE_OPTIONS
-#python "$EXAMPLE_DIR/bubble/periodic_bubble_levelset_penalization.py" $EXAMPLE_OPTIONS
-#python "$EXAMPLE_DIR/bubble/periodic_jet_levelset.py" $EXAMPLE_OPTIONS
-#python "$EXAMPLE_DIR/particles_above_salt/particles_above_salt_periodic.py" $EXAMPLE_OPTIONS
-#python "$EXAMPLE_DIR/particles_above_salt/particles_above_salt_symmetrized.py" $EXAMPLE_OPTIONS
+export HYSOP_VERBOSE=1
+EXAMPLE_DIR="$HYSOP_DIR/../examples"
+EXAMPLE_OPTIONS='-cp default -maxit 2'
+python "$EXAMPLE_DIR/analytic/analytic.py" $EXAMPLE_OPTIONS
+python "$EXAMPLE_DIR/scalar_diffusion/scalar_diffusion.py" $EXAMPLE_OPTIONS
+python "$EXAMPLE_DIR/scalar_advection/scalar_advection.py" $EXAMPLE_OPTIONS
+python "$EXAMPLE_DIR/multiresolution/scalar_advection.py" $EXAMPLE_OPTIONS
+python "$EXAMPLE_DIR/shear_layer/shear_layer.py" $EXAMPLE_OPTIONS
+python "$EXAMPLE_DIR/taylor_green/taylor_green.py" -impl python $EXAMPLE_OPTIONS
+python "$EXAMPLE_DIR/taylor_green/taylor_green.py" -impl opencl $EXAMPLE_OPTIONS
+python -c "from hysop.f2hysop import scales2py as scales" && python "$EXAMPLE_DIR/taylor_green/taylor_green.py" -impl fortran $EXAMPLE_OPTIONS
+python "$EXAMPLE_DIR/bubble/periodic_bubble.py" $EXAMPLE_OPTIONS
+python "$EXAMPLE_DIR/bubble/periodic_bubble_levelset.py" $EXAMPLE_OPTIONS
+python "$EXAMPLE_DIR/bubble/periodic_bubble_levelset_penalization.py" $EXAMPLE_OPTIONS
+python "$EXAMPLE_DIR/bubble/periodic_jet_levelset.py" $EXAMPLE_OPTIONS
+python "$EXAMPLE_DIR/particles_above_salt/particles_above_salt_periodic.py" $EXAMPLE_OPTIONS
+python "$EXAMPLE_DIR/particles_above_salt/particles_above_salt_symmetrized.py" $EXAMPLE_OPTIONS
if [ "$HAS_CACHE_DIR" = true ]; then
cp -r /root/.cache/* $CACHE_DIR/
diff --git a/hysop/backend/device/codegen/base/codegen.py b/hysop/backend/device/codegen/base/codegen.py
index 4f6cfbd38..e5d5eccf3 100644
--- a/hysop/backend/device/codegen/base/codegen.py
+++ b/hysop/backend/device/codegen/base/codegen.py
@@ -468,7 +468,7 @@ class CodeGenerator(object):
header = header_prefix + '{' + header_postfix
self.append(header.split('\n'),newline).indent(count)
- yield
+ yield self
if compact:
self.supress_newline()
self.code += ' '
diff --git a/hysop/backend/device/codegen/symbolic/kernels/custom_symbolic_affect.py b/hysop/backend/device/codegen/symbolic/kernels/custom_symbolic_affect.py
index 4ca96d8ad..54d7363a6 100644
--- a/hysop/backend/device/codegen/symbolic/kernels/custom_symbolic_affect.py
+++ b/hysop/backend/device/codegen/symbolic/kernels/custom_symbolic_affect.py
@@ -8,7 +8,7 @@ from hysop.backend.device.codegen.symbolic.expr import OpenClAssignment, OpenClV
from hysop.backend.device.codegen.base.variables import CodegenVariable, \
CodegenVectorClBuiltin, CodegenArray
from hysop.symbolic.field import SymbolicDiscreteField
-from hysop.symbolic.misc import TimeIntegrate
+from hysop.symbolic.misc import TimeIntegrate, CodeSection
from hysop.symbolic.relational import Assignment
from hysop.symbolic.array import OpenClSymbolicArray, OpenClSymbolicBuffer, IndexedBuffer
from hysop.symbolic.tmp import TmpScalar
@@ -29,19 +29,41 @@ class CustomSymbolicAffectKernelGenerator(CustomSymbolicKernelGenerator):
def build_expr_requirements(self, csc, kernel_reqs, kernel_args, known_vars):
reqs = super(CustomSymbolicAffectKernelGenerator, self).build_expr_requirements(csc, kernel_reqs, kernel_args)
- expr_info = csc.expr_info
- vectorization = csc.vectorization
- typegen = csc.typegen
-
expressions = ()
- fcalls = ()
- is_out_of_date = set()
current_expr = None
out_args = ArgDict()
- is_tmp = False
- for (i,expr) in enumerate(expr_info.extracted_dexprs):
- if isinstance(expr, Assignment):
+ fcalls = []
+ is_out_of_date = set()
+
+ pexprs, findex = self._build_expr_requirements(csc, known_vars,
+ csc.expr_info.dexprs, out_args, fcalls, is_out_of_date, reqs, 0)
+ guard = IfElse(csc.is_active, pexprs)
+ expressions += (guard,)
+
+ lhs = tuple(out_args[vn] for vn in is_out_of_date)
+ rhs = tuple(csc.args[vn] for vn in is_out_of_date)
+ ghosts = tuple(csc.array_ghosts[vn] for vn in is_out_of_date)
+ assert len(lhs) == len(rhs) == len(ghosts)
+ if len(lhs)>0:
+ expressions += (UpdateVars(lhs, rhs, ghosts),)
+
+ self.expressions = expressions
+ self.fcalls = tuple(fcalls)
+ self.out_args = out_args
+ return reqs
+
+ def _build_expr_requirements(self, csc, known_vars,
+ exprs, out_args, fcalls, is_out_of_date, reqs, findex):
+ vectorization = csc.vectorization
+ typegen = csc.typegen
+ pexprs = ()
+ for (i,expr) in enumerate(exprs):
+ if isinstance(expr, CodeSection):
+ section_pexprs, findex = self._build_expr_requirements(csc, known_vars,
+ expr.args, out_args, fcalls, is_out_of_date, reqs, findex+i)
+ pexpr = CodeSection(section_pexprs)
+ elif isinstance(expr, Assignment):
lhs, rhs = expr.args
is_tmp = False
if isinstance(lhs, SymbolicDiscreteField):
@@ -76,39 +98,21 @@ class CustomSymbolicAffectKernelGenerator(CustomSymbolicKernelGenerator):
msg=msg.format(type(lhs))
raise NotImplementedError(msg)
- fname='f{}'.format(i)
+ fname='f{}'.format(findex+i)
rhs_fn = CustomSymbolicFunction(csc=csc, name=fname, expr=rhs, target_ctype=lhs.ctype,
inline=(not csc.tuning_mode), known_args=known_vars)
fn_kwds = rhs_fn.args.copy()
rhs = FunctionCall(rhs_fn.ctype, rhs_fn, fn_kwds)
- fcalls += (rhs,)
+ fcalls.append(rhs)
reqs[fname] = rhs_fn
assert (lhs.ctype == rhs.ctype), '{} != {}'.format(lhs.ctype, rhs.ctype)
pexpr = OpenClAssignment(lhs.ctype, lhs, expr.rel_op, rhs)
- if (current_expr is None):
- current_expr = IfElse(csc.is_active, pexpr)
- expressions += (current_expr,)
- else:
- current_expr.all_exprs[0] += (pexpr,)
-
if not is_tmp:
is_out_of_date.add(vname)
else:
- msg='Unknown expression type {}, valid ones are {}.'
- msg=msg.format(type(expr), (Assignment,))
- raise NotImplementedError(msg)
-
- lhs = tuple(out_args[vn] for vn in is_out_of_date)
- rhs = tuple(csc.args[vn] for vn in is_out_of_date)
- ghosts = tuple(csc.array_ghosts[vn] for vn in is_out_of_date)
- assert len(lhs) == len(rhs) == len(ghosts)
- if len(lhs)>0:
- expressions += (UpdateVars(lhs, rhs, ghosts),)
-
- self.expressions = expressions
- self.fcalls = fcalls
- self.out_args = out_args
- return reqs
+ pexpr = expr
+ pexprs += (pexpr,)
+ return pexprs, findex+i
diff --git a/hysop/backend/device/codegen/symbolic/map.py b/hysop/backend/device/codegen/symbolic/map.py
index 96e8fcc53..ecec79add 100644
--- a/hysop/backend/device/codegen/symbolic/map.py
+++ b/hysop/backend/device/codegen/symbolic/map.py
@@ -14,13 +14,11 @@ from hysop.symbolic.relational import ArithmeticRelation, LogicalRelation, \
from hysop.backend.device.codegen.symbolic.relational import basetype
def map_expression(csc, expr, args, reqs):
- print 'MAP {}'.format(expr)
check_instance(expr, sm.Expr)
promoted_args = ()
try:
ctype, promoted_args = _map_ctypes(expr, args)
func = _map_func(csc, expr, promoted_args, ctype, reqs)
- print func
new_expr = func(ctype, *promoted_args)
if not isinstance(new_expr, TypedI):
msg='New expression is not a TypedI, got a {}.'.format(type(new_expr))
diff --git a/hysop/numerics/fft/host_fft.py b/hysop/numerics/fft/host_fft.py
index 222d61e8a..874bd2fe3 100644
--- a/hysop/numerics/fft/host_fft.py
+++ b/hysop/numerics/fft/host_fft.py
@@ -119,12 +119,12 @@ class HostFFTI(FFTI):
return exec_fill_zeros
def plan_compute_energy(self, tg, src, dst, transforms,
- method='round', target=None):
+ method='round', target=None, **kwds):
"""
Plan to compute energy from src array to dst array using given transforms,
method (round or weighted) and numba target.
"""
- (N, NS2, C2C) = super(HostFFTI, self).plan_compute_energy(tg, src, dst, transforms)
+ (N, NS2, C2C) = super(HostFFTI, self).plan_compute_energy(tg, src, dst, transforms, **kwds)
target = first_not_None(target, __DEFAULT_NUMBA_TARGET__)
args = (src,)+N+NS2+C2C+(dst,)
diff --git a/hysop/numerics/fft/opencl_fft.py b/hysop/numerics/fft/opencl_fft.py
index 88c2b1791..f86cc5011 100644
--- a/hysop/numerics/fft/opencl_fft.py
+++ b/hysop/numerics/fft/opencl_fft.py
@@ -152,7 +152,7 @@ class OpenClFFTI(FFTI):
from hysop.symbolic import local_indices_symbols
from hysop.symbolic.relational import Assignment, LogicalGT
from hysop.symbolic.complex import cabs2
- from hysop.symbolic.misc import Select, CodeSection, CriticalCodeSection
+ from hysop.symbolic.misc import Select, CriticalCodeSection
dim = src.ndim
dtype = src.dtype
ftype = dtype if is_fp(dtype) else complex_to_float_dtype(dtype)
@@ -166,7 +166,6 @@ class OpenClFFTI(FFTI):
K = self.kernel_generator.symbolic_tmp_scalars('K', dtype=itype, count=dim)
exprs = ()
-
assert len(K)==len(I)==len(N)==len(NS2)==len(C2C)
for (Ki, Ii, Ni, Nis2, c2c) in zip(K, I, N, NS2, C2C):
if c2c:
@@ -184,9 +183,9 @@ class OpenClFFTI(FFTI):
exprs += (Assignment(E, cabs2(src)/2),)
action = Assignment(dst[k], dst[k] + E)
- exprs += (CodeSection(action, mutexes, k),)
+ exprs += (CriticalCodeSection(action, mutexes, k),)
- launcher, _ = self.kernel_generator.elementwise_kernel('compute_energy', *exprs, debug=True)
+ launcher, _ = self.kernel_generator.elementwise_kernel('compute_energy', *exprs)
return launcher
@classmethod
diff --git a/hysop/operator/base/custom_symbolic_operator.py b/hysop/operator/base/custom_symbolic_operator.py
index 3817a8240..42e52ca59 100644
--- a/hysop/operator/base/custom_symbolic_operator.py
+++ b/hysop/operator/base/custom_symbolic_operator.py
@@ -494,7 +494,7 @@ class SymbolicExpressionParser(object):
E = ()
for e in exprs:
if isinstance(e, CodeSection):
- E += cls.extract_expressions(e.exprs)
+ E += cls.extract_expressions(e.args)
else:
E += (e,)
return E
@@ -504,7 +504,7 @@ class SymbolicExpressionParser(object):
kind = None
fields = SortedDict()
arrays = SortedDict()
- exprs = cls.extract_expressions(exprs)
+ exprs = filter(lambda e: isinstance(e, ValidExpressions), cls.extract_expressions(exprs))
for expr in exprs:
check_instance(expr, ValidExpressions)
lhs = expr.args[0]
@@ -606,13 +606,15 @@ class SymbolicExpressionParser(object):
@classmethod
def parse_one(cls, variables, info, expr):
- check_instance(expr, ValidExpressions)
if isinstance(expr, Assignment):
cls.parse_assignment(variables, info, *expr.args)
else:
- msg='Invalid symbolic expression type {}, valid ones are {}.'
- msg=msg.format(type(expr), ValidExpressions)
- raise NotImplementedError(msg)
+ try:
+ cls.parse_subexpr(variables, info, expr)
+ except:
+ msg='Invalid symbolic expression type {}, valid ones are {}.'
+ msg=msg.format(type(expr), ValidExpressions)
+ raise NotImplementedError(msg)
@classmethod
def parse_assignment(cls, variables, info, lhs, rhs):
@@ -734,12 +736,23 @@ class SymbolicExpressionParser(object):
field_requirements = SortedDict()
updated_fields = SortedDict()
updated_arrays = SortedDict()
+
+ def check_tmp(i, expr, unknown_tmp):
+ if unknown_tmp:
+ msg='\nError during temporary scalars expansion pass.'
+ msg+='\nSymbolic expressions were:'
+ msg+='\n '+'\n '.join(str(e) for e in info.exprs)
+ msg+='\nExpression {}/ {} use temporary scalars that have not been '
+ msg+='defined yet:{}'
+ msg=msg.format(i, expr, '\n *'+'\n *'.join(tmp.name
+ for tmp in unknown_tmp))
+ raise ValueError(msg)
- # expand tmp scalars into expressions
- exprs = ()
+ # expand tmp scalars into expressions RHS
+ wexprs = ()
+ oexprs = ()
tmp_map = SortedDict()
for (i,expr) in enumerate(info.extracted_exprs):
- print 'EXPR {}'.format(expr)
if isinstance(expr, Assignment):
(lhs, rhs) = expr.args
try:
@@ -747,15 +760,7 @@ class SymbolicExpressionParser(object):
except AttributeError:
rhs_tmp = set()
unknown_tmp = rhs_tmp - set(tmp_map.keys())
- if unknown_tmp:
- msg='\nError during temporary scalars expansion pass.'
- msg+='\nSymbolic expressions were:'
- msg+='\n '+'\n '.join(str(e) for e in info.exprs)
- msg+='\nExpression {}/ {} use temporary scalars that have not been '
- msg+='defined yet:{}'
- msg=msg.format(i, expr, '\n *'+'\n *'.join(tmp.name
- for tmp in unknown_tmp))
- raise ValueError(msg)
+ check_tmp(i, expr, unknown_tmp)
try:
rhs = rhs.xreplace(tmp_map)
except AttributeError:
@@ -763,12 +768,28 @@ class SymbolicExpressionParser(object):
if isinstance(lhs, TmpScalar):
tmp_map[lhs] = rhs
else:
- exprs += (expr.func(lhs,rhs),)
+ wexprs += (expr.func(lhs,rhs),)
else:
- msg='Unsupported type {}.'.format(type(expr))
- raise TypeError(msg)
-
- for (i, expr) in enumerate(exprs):
+ args = expr.args
+ args_tmp = set()
+ _args = ()
+ for a in args:
+ try:
+ atmp = set(filter(lambda v: isinstance(v, TmpScalar), a.free_symbols))
+ args_tmp.update(atmp)
+ except AttributeError:
+ pass
+ unknown_tmp = args_tmp - set(tmp_map.keys())
+ check_tmp(i, expr, unknown_tmp)
+ try:
+ a = a.xreplace(tmp_map)
+ except AttributeError:
+ pass
+ _args += (a,)
+ expr = expr.func(*_args)
+ oexprs += (expr,)
+
+ for (i, expr) in enumerate(wexprs):
obj_reqs = cls._extract_obj_requirements(info, expr)
lhs = expr.args[0]
if isinstance(lhs, sm.Derivative):
@@ -998,26 +1019,7 @@ class SymbolicExpressionParser(object):
@classmethod
def discretize_one(cls, info, expr):
- if isinstance(expr, Assignment):
- return cls.discretize_assignment(info, expr)
- elif isinstance(expr, CodeSection):
- E = ()
- di = ExprDiscretizationInfo()
- for e in expr.exprs:
- e, edi = cls.discretize_one(info, e)
- di.update(edi)
- E += (e,)
- A = ()
- for a in expr.args[1:]:
- a, edi = cls.discretize_subexpr(info, a)
- di.update(edi)
- A += (a,)
- expr = expr.func(*((E,)+A))
- return (expr, di)
- else:
- msg='Invalid symbolic expression type {}, valid ones are {}.'
- msg=msg.format(type(expr), ValidExpressions)
- raise NotImplementedError(msg)
+ return cls.discretize_subexpr(info, expr)
@classmethod
def discretize_assignment(cls, info, expr):
@@ -1074,12 +1076,23 @@ class SymbolicExpressionParser(object):
@classmethod
def discretize_subexpr(cls, info, expr):
- if isinstance(expr, npw.ndarray):
- assert expr.ndim == 0
- expr = expr.tolist()
di = ExprDiscretizationInfo()
- if isinstance(expr, (int,long,float,complex,npw.number)):
+ if isinstance(expr, (list, tuple, set, npw.ndarray)):
+ texpr = type(expr)
+ E = ()
+ for e in expr:
+ e, edi = cls.discretize_subexpr(info, e)
+ di.update(edi)
+ E += (e,)
+ if texpr in (list, tuple, set):
+ expr = texpr(E)
+ else:
+ expr = list(E)
+ return expr, di
+ elif isinstance(expr, (int,long,float,complex,npw.number)):
return expr, di
+ elif isinstance(expr, Assignment):
+ return cls.discretize_assignment(info, expr)
elif cls.should_transpose_expr(info, expr):
expr = cls.transpose_expr(info, expr)
return expr, di
@@ -1129,7 +1142,16 @@ class SymbolicExpressionParser(object):
di.update(edi)
new_args += (arg,)
if new_args:
- return expr.func(*new_args), di
+ try:
+ expr = expr.func(*new_args)
+ except:
+ msg='Failed to build a {} from arguments {}.'
+ msg=msg.format(expr.func, new_args)
+ print
+ print msg
+ print
+ raise
+ return expr, di
else:
return expr, di
else:
diff --git a/hysop/parameters/tensor_parameter.py b/hysop/parameters/tensor_parameter.py
index ad7ad8884..7bc6edfe5 100644
--- a/hysop/parameters/tensor_parameter.py
+++ b/hysop/parameters/tensor_parameter.py
@@ -86,7 +86,7 @@ class TensorParameter(Parameter):
parameter_types += ( np.complex64, np.complex128, np.clongdouble, complex )
initial_value = cls._compute_initial_value(shape, dtype, initial_value,
- min_value, max_value)
+ min_value, max_value, ignore_nans)
obj = super(TensorParameter,cls).__new__(cls,
name=name, pretty_name=pretty_name,
@@ -115,7 +115,7 @@ class TensorParameter(Parameter):
@classmethod
def _compute_initial_value(cls, shape, dtype, initial_value,
- min_value=None, max_value=None):
+ min_value=None, max_value=None, ignore_nans=None):
if not isinstance(dtype, np.dtype):
dtype = np.dtype(dtype)
@@ -146,7 +146,7 @@ class TensorParameter(Parameter):
def reallocate_tensor(self, shape, dtype, initial_value=None):
self._value = self._compute_initial_value(shape, dtype, initial_value,
- min_value=self.min_value, max_value=self.max_value)
+ min_value=self.min_value, max_value=self.max_value, ignore_nans=self.ignore_nans)
self._symbol = self._update_symbol()
def _update_symbol(self):
diff --git a/hysop/symbolic/complex.py b/hysop/symbolic/complex.py
index 1806d48a7..e90e4526e 100644
--- a/hysop/symbolic/complex.py
+++ b/hysop/symbolic/complex.py
@@ -25,7 +25,7 @@ class ComplexBinaryExpr(ComplexExpr):
def __repr__(self):
return '{}({},{})'.format(self.__class__.__name__, repr(self.lhs), repr(self.rhs))
def __str__(self):
- return '{}({},{})'.format(self.fname, self.rhs)
+ return '{}({},{})'.format(self.fname, self.rhs, self.rhs)
def _sympystr(self, printer):
return '{}({},{})'.format(self.fname, printer._print(self.lhs), printer._print(self.rhs))
diff --git a/hysop/symbolic/misc.py b/hysop/symbolic/misc.py
index 94f828be3..4b31db7a8 100644
--- a/hysop/symbolic/misc.py
+++ b/hysop/symbolic/misc.py
@@ -3,6 +3,8 @@ from hysop.deps import sm
from hysop.tools.numpywrappers import npw
from hysop.tools.types import check_instance, first_not_None, to_tuple
from hysop.symbolic import Expr, Symbol
+
+InstructionTermination = ''
class Select(Expr):
def __new__(cls, a, b, c, *args):
@@ -58,28 +60,48 @@ class BroadCast(Expr):
class CodeSection(Expr):
- def __new__(cls, exprs, *args):
- obj = super(CodeSection, cls).__new__(cls, exprs, *args)
- exprs = to_tuple(exprs)
- check_instance(exprs, tuple, values=sm.Expr)
- obj.exprs = exprs
+ def __new__(cls, *exprs):
+ obj = super(CodeSection, cls).__new__(cls, *exprs)
return obj
def _sympystr(self, printer):
return 'CodeSection([{}])'.format(
- '; '.join(printer._print(a) for a in self.exprs))
-
-class CriticalCodeSection(Expr):
- def __new__(cls, exprs, mutexes, mutex_id, *args):
- obj = super(CriticalCodeSection, cls).__new__(cls, exprs, mutexes, mutex_id, *args)
+ '; '.join(printer._print(a) for a in self.args))
+
+ def _ccode(self, printer):
+ codegen = printer.codegen
+ with codegen._block_():
+ for e in self.args:
+ printer._print(e)
+ return InstructionTermination
+
+class MutexOp(Expr):
+ def __new__(cls, mutexes, mutex_id, *args):
+ obj = super(MutexOp, cls).__new__(cls, mutexes, mutex_id, *args)
obj.mutexes = mutexes
obj.mutex_id = mutex_id
return obj
-
+
+class MutexLock(MutexOp):
def _sympystr(self, printer):
- return 'CriticalCodeSection([{}], {}, {})'.format(
- '; '.join(printer._print(a) for a in self.actions),
- printer._print(self.mutexes), printer._print(self.mutex_id))
+ return 'MutexLock({}, {})'.format(
+ printer._print(self.mutexes),
+ printer._print(self.mutex_id))
+ def _ccode(self, printer):
+ codegen = printer.codegen
+ spin='while (atomic_cmpxchg({}+{}, 0, 1) == 1);'
+ spin=spin.format(printer._print(self.mutexes),
+ printer._print(self.mutex_id))
+ codegen.append(spin)
+ return InstructionTermination
+
+def CriticalCodeSection(exprs, mutexes, mutex_id, *args):
+ from hysop.symbolic.relational import Assignment
+ exprs = to_tuple(exprs)
+ mutex_lock = MutexLock(mutexes, mutex_id)
+ mutex_unlock = Assignment(mutexes[mutex_id], 0)
+ exprs = (mutex_lock,) + exprs + (mutex_unlock,)
+ return CodeSection(*exprs)
class ApplyStencil(Expr):
diff --git a/test_examples.sh b/test_examples.sh
index 4af3534c4..28144bfb1 100755
--- a/test_examples.sh
+++ b/test_examples.sh
@@ -18,6 +18,7 @@ EXAMPLE_OPTIONS='-cp default -maxit 2'
python "$EXAMPLE_DIR/analytic/analytic.py" $EXAMPLE_OPTIONS
python "$EXAMPLE_DIR/scalar_diffusion/scalar_diffusion.py" $EXAMPLE_OPTIONS
python "$EXAMPLE_DIR/scalar_advection/scalar_advection.py" $EXAMPLE_OPTIONS
+python "$EXAMPLE_DIR/multiresolution/scalar_advection.py" $EXAMPLE_OPTIONS
python "$EXAMPLE_DIR/shear_layer/shear_layer.py" $EXAMPLE_OPTIONS
python "$EXAMPLE_DIR/taylor_green/taylor_green.py" -impl python $EXAMPLE_OPTIONS
python "$EXAMPLE_DIR/taylor_green/taylor_green.py" -impl opencl $EXAMPLE_OPTIONS
--
GitLab