diff --git a/ci/scripts/test.sh b/ci/scripts/test.sh
index 61af094eaef5de9498df15ad76c813ed4f0407cb..a2a1f0382020557a4901d658a44c4cf8753dbc92 100755
--- a/ci/scripts/test.sh
+++ b/ci/scripts/test.sh
@@ -73,6 +73,7 @@ export HYSOP_DEBUG=0
export HYSOP_PROFILE=0
export HYSOP_KERNEL_DEBUG=0
export HYSOP_TRACE_WARNINGS=1
+export PYOPENCL_COMPILER_OUTPUT=0
# OpenMPI specific variables
export OMPI_ALLOW_RUN_AS_ROOT=1
@@ -115,9 +116,9 @@ example_test() {
if [ "$RUN_TESTS" = true ]; then
#hysop_test "core/arrays/tests/test_array.py"
- hysop_test "core/graph/tests/test_graph.py"
- hysop_test "fields/tests/test_fields.py"
- hysop_test "numerics/tests/test_fft.py"
+ #hysop_test "core/graph/tests/test_graph.py"
+ #hysop_test "fields/tests/test_fields.py"
+ #hysop_test "numerics/tests/test_fft.py"
hysop_test "operator/tests/test_analytic.py"
hysop_test "operator/tests/test_transpose.py"
hysop_test "operator/tests/test_fd_derivative.py"
diff --git a/hysop/__init__.py.in b/hysop/__init__.py.in
index 9107971480f38e9dd637b24b1bf114a7f6c6c88e..0da4c6dfb2fb68915e49934724b3a55a7041a023 100644
--- a/hysop/__init__.py.in
+++ b/hysop/__init__.py.in
@@ -130,11 +130,17 @@ def reset():
# override warning printer
if '__formatwarning' not in locals():
__formatwarning = warnings.formatwarning
-def __new_formatwarning(message, category, filename, lineno, line=None):
- if __TRACE_WARNINGS__:
+def __new_formatwarning(warning, category, filename, lineno, line=None):
+ # filter out useless intel opencl build "warnings" stacktraces
+ message = str(warning)
+ if ('Compilation started' in message) and ('Done.' in message):
+ pass
+ elif ('Non-empty compiler output encountered.' in message):
+ pass
+ elif __TRACE_WARNINGS__:
print('::WARNING STACK TRACE::')
traceback.print_stack()
- return __formatwarning(message, category, filename, lineno, line='')
+ return __formatwarning(warning, category, filename, lineno, line=line)
warnings.formatwarning = __new_formatwarning
if __TRACE_CALLS__:
diff --git a/hysop/backend/device/autotunable_kernel.py b/hysop/backend/device/autotunable_kernel.py
index f63236a6109f5ddd39abbffec11a942f6a632426..550da661ff080da8228553f635c07439c5dec2c7 100644
--- a/hysop/backend/device/autotunable_kernel.py
+++ b/hysop/backend/device/autotunable_kernel.py
@@ -707,7 +707,7 @@ class AutotunerWorkConfiguration(object):
for fname in self.filter_names:
fn = self._filters[fname]
- candidates = it.ifilter(fn, candidates)
+ candidates = filter(fn, candidates)
if self.__debug_filters:
candidates, _ = it.tee(candidates)
msg=' *Filter {}:\n {}\n'.format(fname,
diff --git a/hysop/backend/device/codegen/base/utils.py b/hysop/backend/device/codegen/base/utils.py
index c8528608fde2c50f022441907f21798a87f9a7fc..d530944259d304daf05d98c7e6504717f82dca2c 100644
--- a/hysop/backend/device/codegen/base/utils.py
+++ b/hysop/backend/device/codegen/base/utils.py
@@ -134,7 +134,7 @@ class ArgDict(WriteOnceDict):
# robust with up to 256 functions with the same basename
# max_fun = sqrt(16**nb) = 2**(2*nb)
def hash(self,string):
- return hashlib.sha1(string).hexdigest()[:4]
+ return hashlib.sha1(string.encode('utf-8')).hexdigest()[:4]
class SortedDict(dict):
diff --git a/hysop/backend/device/codegen/base/variables.py b/hysop/backend/device/codegen/base/variables.py
index d93169010460cd19df111e9e9a8fc2e32d269066..55489215e308ab17d6febc67979b2657827ecfd9 100644
--- a/hysop/backend/device/codegen/base/variables.py
+++ b/hysop/backend/device/codegen/base/variables.py
@@ -828,6 +828,8 @@ class CodegenVectorClBuiltin(CodegenVector):
def __getitem__(self, key):
dim = self.dim
+ if isinstance(key, range):
+ key = tuple(key)
if isinstance(key,slice) :
ids = range(*key.indices(dim))
if self.declared and key.indices(dim)==(0,dim,1):
diff --git a/hysop/backend/device/codegen/kernels/custom_symbolic.py b/hysop/backend/device/codegen/kernels/custom_symbolic.py
index acd48ab176cf0a50c5d8447e2e089fa6a9835eae..a7e5c9a7f5cd3ae67cb1bb11722d939b80bd7af3 100644
--- a/hysop/backend/device/codegen/kernels/custom_symbolic.py
+++ b/hysop/backend/device/codegen/kernels/custom_symbolic.py
@@ -241,8 +241,8 @@ class SymbolicCodegenContext(object):
array_contiguous_ghosts = SortedDict()
array_sizes = SortedDict()
- dfields = set(f.dfield for f in (expr_info.input_dfields.values() +
- expr_info.output_dfields.values()))
+ dfields = set(f.dfield for f in set(expr_info.input_dfields.values()).union(
+ expr_info.output_dfields.values()))
for dfield in dfields:
field = dfield._field
diff --git a/hysop/backend/device/codegen/symbolic/relational.py b/hysop/backend/device/codegen/symbolic/relational.py
index 0f85cd26daa719e4e484badae5a6c4d88515a8c3..3f712255d44e60d7d3235813d0ee90319e55b286 100644
--- a/hysop/backend/device/codegen/symbolic/relational.py
+++ b/hysop/backend/device/codegen/symbolic/relational.py
@@ -8,7 +8,7 @@ from hysop.symbolic.relational import LogicalAND, LogicalOR, LogicalXOR, \
Mul, Pow, Add
def basetype(fulltype):
import string
- return fulltype.translate(None, string.digits)
+ return fulltype.translate(str.maketrans('', '', string.digits))
class RelationalTypedExpr(TypedI):
def __new__(cls, ctype, *args, **kwds):
diff --git a/hysop/backend/device/kernel_autotuner.py b/hysop/backend/device/kernel_autotuner.py
index f4a6e9096f3a119a2c86ffea11a1420332bb00a9..f1ad2f8e01003f634f269b0473bf81bf8c9b3c34 100644
--- a/hysop/backend/device/kernel_autotuner.py
+++ b/hysop/backend/device/kernel_autotuner.py
@@ -120,7 +120,7 @@ class KernelAutotuner(object, metaclass=ABCMeta):
extra_kwds_hash, extra_kwds_hash_logs = tkernel.hash_extra_kwds(extra_kwds)
hasher = self._hash_func()
- hasher.update(str(extra_kwds_hash))
+ hasher.update(str(extra_kwds_hash).encode('utf-8'))
extra_kwds_hash = hasher.hexdigest()
check_instance(extra_kwds_hash, str)
check_instance(extra_kwds_hash_logs, str)
@@ -300,12 +300,14 @@ class KernelAutotuner(object, metaclass=ABCMeta):
max_kernel_work_group_size=max_kernel_work_group_size,
preferred_work_group_size_multiple=preferred_work_group_size_multiple)
except Exception as e:
+ raise
msg = 'Autotuner could not determine kernel info for parameters {} because of the following KernelGenerationError:\n{}\n'
msg = msg.format(extra_parameters, e)
warnings.warn(msg, CodeGeneratorWarning)
pks = ks.push_parameters(extra_param_hash, extra_parameters=extra_parameters)
continue
+
work_bounds = tkernel.compute_work_bounds(max_kernel_work_group_size=max_kernel_work_group_size,
preferred_work_group_size_multiple=preferred_work_group_size_multiple,
extra_parameters=extra_parameters,
@@ -349,7 +351,7 @@ class KernelAutotuner(object, metaclass=ABCMeta):
tuning_mode=True, dry_run=False)
hasher = self._hash_func()
- hasher.update(kernel_src)
+ hasher.update(kernel_src.encode('utf-8'))
src_hash = hasher.hexdigest()
if (run_key in results):
diff --git a/hysop/backend/device/opencl/autotunable_kernels/custom_symbolic.py b/hysop/backend/device/opencl/autotunable_kernels/custom_symbolic.py
index 82d6e8f77bfd6aee16a9de6eb1fca06c8029eac3..5e3ac78d638dfe42fa86254293fabcb0829a5b36 100644
--- a/hysop/backend/device/opencl/autotunable_kernels/custom_symbolic.py
+++ b/hysop/backend/device/opencl/autotunable_kernels/custom_symbolic.py
@@ -36,8 +36,8 @@ class OpenClAutotunableCustomSymbolicKernel(OpenClAutotunableKernel):
hardcode_arrays means that array offset and strides can be hardcoded
into the kernels as constants.
"""
- check_instance(expr_info.input_dfields.values(), list, values=CartesianDiscreteScalarFieldView)
- check_instance(expr_info.output_dfields.values(), list, values=CartesianDiscreteScalarFieldView)
+ check_instance(tuple(expr_info.input_dfields.values()), tuple, values=CartesianDiscreteScalarFieldView)
+ check_instance(tuple(expr_info.output_dfields.values()), tuple, values=CartesianDiscreteScalarFieldView)
granularity = expr_info.compute_granularity
diff --git a/hysop/backend/device/opencl/opencl_env.py b/hysop/backend/device/opencl/opencl_env.py
index 1615d0cd4d473bc48af7ac358b9f1c17629df53f..010152196f5ef543ea6199aa22e77df3b01769ee 100644
--- a/hysop/backend/device/opencl/opencl_env.py
+++ b/hysop/backend/device/opencl/opencl_env.py
@@ -564,7 +564,7 @@ Dumped OpenCL Kernel '{}'
gpu_src = src
- src_hash = hashlib.sha1(gpu_src).hexdigest()
+ src_hash = hashlib.sha1(gpu_src.encode('utf-8')).hexdigest()
if (kernel_name is None):
kernel_name = src_hash
else:
diff --git a/hysop/backend/device/opencl/opencl_operator.py b/hysop/backend/device/opencl/opencl_operator.py
index 5359257012ec78f11fe07bf35150ebde20c662c4..773b6c8796ed872ec34798cb32bee8f849ea0a45 100644
--- a/hysop/backend/device/opencl/opencl_operator.py
+++ b/hysop/backend/device/opencl/opencl_operator.py
@@ -46,6 +46,11 @@ class OpenClOperator(ComputationalGraphOperator, metaclass=ABCMeta):
am.update(cls.__available_methods)
return am
+ @debug
+ def __new__(cls, cl_env=None, mpi_params=None,
+ requested_symbolic_kernels=None, **kwds):
+ return super(OpenClOperator, cls).__new__(cls, mpi_params=mpi_params, **kwds)
+
@debug
def __init__(self, cl_env=None, mpi_params=None,
requested_symbolic_kernels=None, **kwds):
diff --git a/hysop/backend/device/opencl/opencl_types.py b/hysop/backend/device/opencl/opencl_types.py
index 276852313bb235e661862e871cab04ad0611cd25..000dd1515a2ced814f02283b1a4ec792eaf4e44e 100644
--- a/hysop/backend/device/opencl/opencl_types.py
+++ b/hysop/backend/device/opencl/opencl_types.py
@@ -55,9 +55,9 @@ FLT_BYTES = {
}
def basetype(fulltype):
- return fulltype.translate(None,string.digits)
+ return fulltype.translate(str.maketrans('', '', string.digits))
def components(fulltype):
- comp = fulltype.translate(None,string.ascii_letters+'_')
+ comp = fulltype.translate(str.maketrans('', '', string.ascii_letters+'_'))
return 1 if comp == '' else int(comp)
def mangle_vtype(fulltype):
return basetype(fulltype)[0]+str(components(fulltype))
diff --git a/hysop/backend/device/opencl/operator/analytic.py b/hysop/backend/device/opencl/operator/analytic.py
index 916ea10ae34f194ad9928831115df67ae854e241..c601c860e3a6db007be351ec3d1d924d5996fec2 100644
--- a/hysop/backend/device/opencl/operator/analytic.py
+++ b/hysop/backend/device/opencl/operator/analytic.py
@@ -14,11 +14,17 @@ class OpenClAnalyticField(OpenClCustomSymbolicOperator):
"""
@debug
- def __init__(self, field, formula, variables, **kwds):
+ def __new__(cls, field, formula, variables, **kwds):
+ name = kwds.pop('name', 'analytic_{}'.format(field.name))
+ return super(OpenClAnalyticField, cls).__new__(cls, name=None, exprs=None,
+ variables=variables, **kwds)
+
+ @debug
+ def __init__(self, field, formula, variables, **kwds):
"""
Initialize a Analytic operator on the python backend.
- Apply a user-defined formula onto a field, possibly
+ Apply a user-defined formula onto a field, possibly
dependent on space variables and external fields/parameters.
Parameters
@@ -36,23 +42,23 @@ class OpenClAnalyticField(OpenClCustomSymbolicOperator):
check_instance(field, ScalarField)
check_instance(formula, tuple, values=(type(None),sm.Basic), size=field.nb_components)
check_instance(variables, dict, keys=Field, values=CartesianTopologyDescriptors)
-
+
exprs = ()
Fs = to_tuple(field.s())
for (lhs,rhs) in zip(Fs, formula):
if (rhs is None):
continue
exprs += (Assignment(lhs, rhs),)
-
+
if not exprs:
msg='All formulas are None. Give at least one expression.'
raise ValueError(msg)
name = kwds.pop('name', 'analytic_{}'.format(field.name))
- super(OpenClAnalyticField, self).__init__(name=name, exprs=exprs,
+ super(OpenClAnalyticField, self).__init__(name=name, exprs=exprs,
variables=variables, **kwds)
-
+
@classmethod
def supports_mpi(cls):
return True
diff --git a/hysop/backend/device/opencl/operator/custom_symbolic.py b/hysop/backend/device/opencl/operator/custom_symbolic.py
index af43ecaaf82dc6bbd59fa0f14fd25e23a7b72cfe..7dd7735f67fe24fbf703cbfefdec201507561303 100644
--- a/hysop/backend/device/opencl/operator/custom_symbolic.py
+++ b/hysop/backend/device/opencl/operator/custom_symbolic.py
@@ -10,10 +10,14 @@ from hysop.backend.device.opencl.opencl_copy_kernel_launchers import OpenClCopyB
class OpenClCustomSymbolicOperator(CustomSymbolicOperatorBase, OpenClOperator):
+ @debug
+ def __new__(cls, **kwds):
+ return super(OpenClCustomSymbolicOperator, cls).__new__(cls, **kwds)
+
@debug
def __init__(self, **kwds):
super(OpenClCustomSymbolicOperator, self).__init__(**kwds)
-
+
@debug
def setup(self, work):
super(OpenClCustomSymbolicOperator, self).setup(work)
@@ -25,30 +29,30 @@ class OpenClCustomSymbolicOperator(CustomSymbolicOperatorBase, OpenClOperator):
for sout in self.output_discrete_fields.values():
kl += sout.exchange_ghosts(build_launcher=True)
self.kl = kl
-
+
def _collect_symbolic_kernel(self):
cl_env = self.cl_env
typegen = self.typegen
autotuner_config = self.autotuner_config
build_opts = self.build_options()
-
- kernel_autotuner = OpenClAutotunableCustomSymbolicKernel(cl_env=cl_env, typegen=typegen,
+
+ kernel_autotuner = OpenClAutotunableCustomSymbolicKernel(cl_env=cl_env, typegen=typegen,
build_opts=build_opts, autotuner_config=autotuner_config)
kernel, args_dict, update_input_parameters = kernel_autotuner.autotune(expr_info=self.expr_info)
-
+
kl = kernel.build_launcher(**args_dict)
self._symbolic_kernel_kl = kl
self._update_input_params = update_input_parameters
return kl
-
+
@op_apply
def apply(self, **kwds):
queue = self.cl_env.default_queue
evt = self.kl(queue=queue, **self._update_input_params())
-
+
@classmethod
def supports_mpi(cls):
return True
diff --git a/hysop/backend/hardware/machine.py b/hysop/backend/hardware/machine.py
index 80c910198cb3d86280fdb5e262d5eabf92a0dd45..f41ca8bd8009e75bfa736b2200c566df8964b8f0 100644
--- a/hysop/backend/hardware/machine.py
+++ b/hysop/backend/hardware/machine.py
@@ -11,7 +11,7 @@ from hysop.backend.hardware.pci import PciBridge
class NumaNode(TopologyObject):
"""
- A set of processors around memory which the processors can directly access.
+ A set of processors around memory which the processors can directly access.
"""
def __init__(self, parent, node, package=None, bridge=None):
if (node is not None):
@@ -54,7 +54,7 @@ class NumaNode(TopologyObject):
return len(self._bridges)
def pci_devices_count(self):
return sum(x.pci_device_count() for x in self._bridges)
-
+
def cpu_packages(self):
return self.packages()
def pci_devices(self):
@@ -80,10 +80,10 @@ node memory: {}
for bridge in self.bridges():
content += self.indent(bridge.to_string(expand_pci_tree=expand_pci_tree))
return header + self.indent(content)
-
+
def _parsed_type(self):
return 'NUMANode'
-
+
def _parse_object(self, it):
_type = it.attrib['type']
if _type == 'Package':
@@ -110,7 +110,7 @@ class Machine(TopologyObject):
"""
Class describing a physical machine (a set of processors and memory).
"""
-
+
def __init__(self, parent, machine):
if platform.system() == 'Windows':
system = System.WINDOWS
@@ -121,30 +121,30 @@ class Machine(TopologyObject):
else:
msg='Unknown platform system {}.'.format(platform.system())
raise ValueError(msg)
-
+
self._system = system
self._bridge, self._package = None, None
self._numa_nodes = []
super(Machine,self).__init__(parent, machine)
-
+
def _post_init(self):
if self._package:
self._attributes['nodeset'] = 1
- attr = {'local_memory': self.pop_attr('local_memory'),
+ attr = {'local_memory': self.pop_attr('local_memory'),
'os_index': self.pop_attr('os_index'),
'cpuset': self.cpu_set(),
'nodeset': 1}
- self._numa_nodes = [ NumaNode.from_package(parent=self, attributes=attr,
+ self._numa_nodes = [ NumaNode.from_package(parent=self, attributes=attr,
package=self._package, bridge=self._bridge) ]
elif self._numa_nodes:
pass
else:
raise RuntimeError('Something went wrong during parsing.')
-
+
def _parsed_type(self):
return 'Machine'
-
+
def _handle_child(self, child):
if child.tag=='page_type':
self._parse_page_type(child)
@@ -167,7 +167,7 @@ class Machine(TopologyObject):
else:
raise ValueError('Unknown object type {} obtained during Machine parsing.'.format(_type))
-
+
## Machine information
def system(self):
return self._system
@@ -205,9 +205,9 @@ class Machine(TopologyObject):
def pci_devices(self, vendor_id=None, device_id=None):
devices = it.chain.from_iterable([x.pci_devices() for x in self.numa_nodes()])
if (vendor_id is not None):
- devices = it.ifilter(lambda x: x.pci_system_vendor_id() == vendor_id, devices)
+ devices = filter(lambda x: x.pci_system_vendor_id() == vendor_id, devices)
if (device_id is not None):
- devices = it.ifilter(lambda x: x.pci_system_device_id() == device_id, devices)
+ devices = filter(lambda x: x.pci_system_device_id() == device_id, devices)
return tuple(devices)
def architecture(self):
@@ -217,7 +217,7 @@ class Machine(TopologyObject):
return '{} {}'.format(
self.attribute('backend'),
self.attribute('architecture'))
-
+
def os(self):
return '{} {} ({})'.format(
self.attribute('os_name'),
@@ -246,7 +246,7 @@ class Machine(TopologyObject):
return self.to_string(expand_pci_tree=True)
def to_string(self, expand_pci_tree=True):
- header = '== Physical Hardware Report =='
+ header = '== Physical Hardware Report =='
content = \
'''
bios: {}
@@ -282,6 +282,6 @@ physical memory: {}
content += '\nHardware info gathered with {}'.format(self.hwinfo_version())
- footer = '\n===================='
-
+ footer = '\n===================='
+
return header + self.indent(content) + footer
diff --git a/hysop/backend/host/host_operator.py b/hysop/backend/host/host_operator.py
index 8c86415aba72e881abbce545799ea512ea369a9c..f52750eee4c8bba434dd6367116cedc111d375b1 100644
--- a/hysop/backend/host/host_operator.py
+++ b/hysop/backend/host/host_operator.py
@@ -19,6 +19,10 @@ class HostOperator(ComputationalGraphOperator, metaclass=ABCMeta):
Abstract class for discrete operators working on OpenCL backends.
"""
+ @debug
+ def __new__(cls, **kwds):
+ return super(HostOperator, cls).__new__(cls, **kwds)
+
@debug
def __init__(self, **kwds):
"""
@@ -44,7 +48,10 @@ class OpenClMappable(object):
"""
class OpenClMappedMemoryObjectGetter(object):
+ def __new__(cls, obj, evt):
+ return super(OpenClMappedMemoryObjectGetter, cls).__new__(cls)
def __init__(self, obj, evt):
+ super(OpenClMappedMemoryObjectGetter, self).__init__()
check_instance(obj, OpenClMappable)
self.__obj = obj
self.__evt = evt
@@ -84,6 +91,10 @@ class OpenClMappable(object):
else:
super(OpenClMappable, self).create_topology_descriptors()
+ def __new__(cls, cl_env=None, mpi_params=None,
+ enable_opencl_host_buffer_mapping=False, **kwds):
+ return super(OpenClMappable, cls).__new__(cls, mpi_params=mpi_params, **kwds)
+
def __init__(self, cl_env=None, mpi_params=None,
enable_opencl_host_buffer_mapping=False, **kwds):
diff --git a/hysop/backend/host/python/operator/analytic.py b/hysop/backend/host/python/operator/analytic.py
index b95c358d02ab1af53edff9f6db35b91a489a1369..10eb14efd0aa4561702d698a981676eb33df962e 100644
--- a/hysop/backend/host/python/operator/analytic.py
+++ b/hysop/backend/host/python/operator/analytic.py
@@ -13,6 +13,14 @@ class PythonAnalyticField(HostOperator):
Formula is given as a python method that operates on numpy arrays.
"""
+ @debug
+ def __new__(cls, field, formula, variables,
+ extra_input_kwds=None, **kwds):
+ return super(PythonAnalyticField, cls).__new__(cls,
+ input_fields=None,
+ output_fields=None,
+ input_params=None, **kwds)
+
@debug
def __init__(self, field, formula, variables,
extra_input_kwds=None, **kwds):
diff --git a/hysop/core/graph/computational_operator.py b/hysop/core/graph/computational_operator.py
index 8794230145216accb6e258e3212b48868be8cc1f..a250c4f939f9fe74318ce30e03f0953f8b2541c9 100644
--- a/hysop/core/graph/computational_operator.py
+++ b/hysop/core/graph/computational_operator.py
@@ -119,6 +119,11 @@ class ComputationalGraphOperator(ComputationalGraphNode, metaclass=ABCMeta):
or at least, a child class of hysop.core.graph.computational_graph.ComputationalGraph.
"""
+ @debug
+ def __new__(cls, input_fields=None, output_fields=None, **kwds):
+ return super(ComputationalGraphOperator, cls).__new__(cls,
+ input_fields=input_fields, output_fields=output_fields, **kwds)
+
@debug
def __init__(self, input_fields=None, output_fields=None, **kwds):
"""
diff --git a/hysop/core/graph/continuous.py b/hysop/core/graph/continuous.py
index 59c21fa822eb64cf8518eebd390aed6a50fea3eb..5374fd3494fbc4ac917abcb8c0c1cfd6edae4814 100755
--- a/hysop/core/graph/continuous.py
+++ b/hysop/core/graph/continuous.py
@@ -24,17 +24,11 @@ class OperatorBase(TaggedObject, metaclass=ABCMeta):
@debug
def __new__(cls, name, fields, tensor_fields, parameters,
- mpi_params=None,
- io_params=False,
- **kwds):
- return super(OperatorBase, cls).__new__(cls, tagged_cls=OperatorBase, tag_prefix='node',
- **kwds)
+ mpi_params=None, io_params=False, **kwds):
+ return super(OperatorBase, cls).__new__(cls, tagged_cls=OperatorBase, tag_prefix='node', **kwds)
@debug
- def __init__(self, name, fields, tensor_fields, parameters,
- mpi_params=None,
- io_params=False,
- **kwds):
+ def __init__(self, name, fields, tensor_fields, parameters, mpi_params=None, io_params=False, **kwds):
"""
Parameters
----------
@@ -61,8 +55,7 @@ class OperatorBase(TaggedObject, metaclass=ABCMeta):
mpi_params: MPIParams
File i/o config (filename, format ...)
"""
- super(OperatorBase,self).__init__(tagged_cls=OperatorBase, tag_prefix='node',
- **kwds)
+ super(OperatorBase,self).__init__(tagged_cls=OperatorBase, tag_prefix='node', **kwds)
check_instance(fields, tuple, values=ScalarField)
check_instance(tensor_fields, tuple, values=TensorField)
diff --git a/hysop/numerics/fft/fftw_fft.py b/hysop/numerics/fft/fftw_fft.py
index 010419fed1810696e8a31e36c818fd163499c8bf..dbf09acfea1baab0948e1241e7efb66531ad5791 100644
--- a/hysop/numerics/fft/fftw_fft.py
+++ b/hysop/numerics/fft/fftw_fft.py
@@ -68,7 +68,7 @@ class FftwFFTPlan(HostFFTPlanI):
return 'shape={:<16} strides={:<16} dtype={:<16}'.format(
str(arr.shape)+',',
str(arr.strides)+',',
- arr.dtype)
+ str(arr.dtype))
title=' Planning {} '.format(self.__class__.__name__)
msg = \
diff --git a/hysop/numerics/fft/gpyfft_fft.py b/hysop/numerics/fft/gpyfft_fft.py
index e49ffecd98856225a08e99815665404f9622a3e3..e5de67e094e6433bdfee690d24123bcc8c323180 100644
--- a/hysop/numerics/fft/gpyfft_fft.py
+++ b/hysop/numerics/fft/gpyfft_fft.py
@@ -416,14 +416,16 @@ Post callback source code:
# Keep a reference to callback source code to prevent dangling const char* pointers.
# Do not remove because clfft only get the pointer and gpyfft does not increase the
# refcount of those strings, resulting in random code injection into the fft kernels.
+ pre_src = pre_src.encode('ascii')
+ post_src = post_src.encode('ascii')
self.pre_callback_src = pre_src
self.post_callback_src = post_src
# ***********************************************************************************
if (pre_src is not None):
- plan.set_callback('pre_callback', pre_src, 'pre', user_data=user_data)
+ plan.set_callback(b'pre_callback', pre_src, 'pre', user_data=user_data)
if (post_src is not None):
- plan.set_callback('post_callback', post_src, 'post', user_data=user_data)
+ plan.set_callback(b'post_callback', post_src, 'post', user_data=user_data)
return (in_data, out_data)
@classmethod
@@ -640,7 +642,7 @@ Post callback source code:
return 'shape={:<16} strides={:<16} dtype={:<16}'.format(
str(arr.shape)+',',
str(arr.strides)+',',
- arr.dtype)
+ str(arr.dtype))
title=' Baking {} '.format(self.__class__.__name__)
msg = \
''' in_array: {}
diff --git a/hysop/numerics/stencil/stencil.py b/hysop/numerics/stencil/stencil.py
index f7d3b1688cc40bfb42b2d7127013c49efb3a4c7b..05c1b91b3a54577f4c33f12346ab6b0c39031e21 100644
--- a/hysop/numerics/stencil/stencil.py
+++ b/hysop/numerics/stencil/stencil.py
@@ -277,7 +277,7 @@ class Stencil(object):
return (offset,value)
iterator = np.ndindex(self.shape)
iterator = it.imap(mapfun, iterator)
- iterator = it.ifilter(lambda x: x[1]!=0, iterator)
+ iterator = filter(lambda x: x[1]!=0, iterator)
return iterator
def refactor(self, factor):
diff --git a/hysop/numerics/stencil/stencil_generator.py b/hysop/numerics/stencil/stencil_generator.py
index 8bc242389f1a6909b07b53e08d1251300551be86..856b2a53922a09223f00621f86572a72a808596a 100644
--- a/hysop/numerics/stencil/stencil_generator.py
+++ b/hysop/numerics/stencil/stencil_generator.py
@@ -459,8 +459,8 @@ class StencilGenerator(object):
return (it<=N).all() and sum(it)==n
nn = range(n+1)
- itd = it.product(nn,repeat=dim)
- itd = it.ifilter(preficate,itd)
+ itd = it.product(nn, repeat=dim)
+ itd = filter(preficate, itd)
expr = 0
for der in itd:
expr += taylorn_term(df,dx,der)
diff --git a/hysop/numerics/tests/test_fft.py b/hysop/numerics/tests/test_fft.py
index 9e50d506c1da6ffff1f7e5a9bc495ab320ec2ae1..ca4dc8b836afc9e94b3cb65b265074b08f499449 100644
--- a/hysop/numerics/tests/test_fft.py
+++ b/hysop/numerics/tests/test_fft.py
@@ -45,14 +45,14 @@ class TestFFT(object):
print()
print(':: STARTING FFT BACKEND TESTS ::')
- #for (i,cl_env) in enumerate(iter_clenv()):
- #print('> Registering opencl backend {} as:\n{}'.format(i, cl_env))
- #print()
- #name = 'clfft{}'.format(i)
- #implementations[Implementation.OPENCL][name] = \
- #GpyFFT(cl_env=cl_env,
- #warn_on_allocation=False,
- #warn_on_unaligned_output_offset=False)
+ for (i,cl_env) in enumerate(iter_clenv()):
+ print('> Registering opencl backend {} as:\n{}'.format(i, cl_env))
+ print()
+ name = 'clfft{}'.format(i)
+ implementations[Implementation.OPENCL][name] = \
+ GpyFFT(cl_env=cl_env,
+ warn_on_allocation=False,
+ warn_on_unaligned_output_offset=False)
msg_shape = 'Expected output array shape to be {} but got {} for implementation {}.'
msg_dtype = 'Expected output array dtype to be {} but got {} for implementation {}.'
@@ -75,7 +75,7 @@ class TestFFT(object):
print('no support')
return
elif len(results.keys())==1:
- impl = results.keys()[0]
+ impl = next(iter(results.keys()))
print('cannot compare')
return
ss=()
@@ -112,7 +112,7 @@ class TestFFT(object):
print('\n FORWARD C2C: complex to complex forward transform')
for (shape, cshape, rshape, N, Nc, Nr,
ghosts, mk_buffer) in self.iter_shapes():
- print(' FFT shape={:12s} ghosts={:12s} '.format(shape, str(ghosts)+':'),)
+ print(' FFT shape={:12s} ghosts={:12s} '.format(str(shape), str(ghosts)+':'), end=' ')
Href = np.random.rand(2*N).astype(dtype).view(dtype=ctype).reshape(shape)
results = {}
for (kind, implementations) in self.implementations.items():
@@ -146,7 +146,7 @@ class TestFFT(object):
print('\n BACKWARD C2C: complex to complex backward transform')
for (shape, cshape, rshape, N, Nc, Nr,
ghosts, mk_buffer) in self.iter_shapes():
- print(' IFFT shape={:12s} ghosts={:12s} '.format(shape, str(ghosts)+':'),)
+ print(' IFFT shape={:12s} ghosts={:12s} '.format(str(shape), str(ghosts)+':'), end=' ')
Href = np.random.rand(2*N).astype(dtype).view(dtype=ctype).reshape(shape)
results = {}
for (kind, implementations) in self.implementations.items():
@@ -180,7 +180,7 @@ class TestFFT(object):
print('\n FORWARD R2C: real to hermitian complex transform')
for (shape, cshape, rshape, N, Nc, Nr,
ghosts, mk_buffer) in self.iter_shapes():
- print(' RFFT shape={:12s} ghosts={:12s} '.format(shape, str(ghosts)+':'), end=' ')
+ print(' RFFT shape={:12s} ghosts={:12s} '.format(str(shape), str(ghosts)+':'), end=' ')
Href = np.random.rand(*shape).astype(dtype).reshape(shape)
results = {}
for (kind, implementations) in self.implementations.items():
@@ -214,7 +214,7 @@ class TestFFT(object):
print('\n BACKWARD C2R: real to hermitian complex transform')
for (shape, cshape, rshape, N, Nc, Nr,
ghosts, mk_buffer) in self.iter_shapes():
- print(' IRFFT shape={:12s} ghosts={:12s} '.format(shape, str(ghosts)+':'), end=' ')
+ print(' IRFFT shape={:12s} ghosts={:12s} '.format(str(shape), str(ghosts)+':'), end=' ')
Href = np.random.rand(2*Nc).astype(dtype).view(dtype=ctype).reshape(cshape)
results = {}
for (kind, implementations) in self.implementations.items():
@@ -248,7 +248,7 @@ class TestFFT(object):
print('\n BACKWARD FORCED C2R: real to hermitian complex transform with specified shape')
for (shape, cshape, rshape, N, Nc, Nr,
ghosts, mk_buffer) in self.iter_shapes():
- print(' IRFFT shape={:12s} ghosts={:12s} '.format(shape, str(ghosts)+':'), end=' ')
+ print(' IRFFT shape={:12s} ghosts={:12s} '.format(str(shape), str(ghosts)+':'), end=' ')
Href = np.random.rand(2*Nc).astype(dtype).view(dtype=ctype).reshape(cshape)
results = {}
for (kind, implementations) in self.implementations.items():
@@ -285,7 +285,7 @@ class TestFFT(object):
stype.strip(), itype))
for (shape, cshape, rshape, N, Nc, Nr,
ghosts, mk_buffer) in self.iter_shapes():
- print(' DCT-{} shape={:12s} ghosts={:12s} '.format(stype, shape, str(ghosts)+':'), end=' ')
+ print(' DCT-{} shape={:12s} ghosts={:12s} '.format(stype, str(shape), str(ghosts)+':'), end=' ')
if (itype==1): # real size is 2*(N-1)
shape = mk_shape(shape, -1, shape[-1] + 1)
Href = np.random.rand(*shape).astype(dtype).reshape(shape)
@@ -327,7 +327,7 @@ class TestFFT(object):
stype.strip(), itype))
for (shape, cshape, rshape, N, Nc, Nr,
ghosts, mk_buffer) in self.iter_shapes():
- print(' IDCT-{} shape={:12s} ghosts={:12s} '.format(stype, shape, str(ghosts)+':'), end=' ')
+ print(' IDCT-{} shape={:12s} ghosts={:12s} '.format(stype, str(shape), str(ghosts)+':'), end=' ')
if (iitype==1): # real size is 2*(N-1)
shape = mk_shape(shape, -1, shape[-1] + 1)
Href = np.random.rand(*shape).astype(dtype).reshape(shape)
@@ -369,7 +369,7 @@ class TestFFT(object):
stype.strip(), itype))
for (shape, cshape, rshape, N, Nc, Nr,
ghosts, mk_buffer) in self.iter_shapes():
- print(' DST-{} shape={:12s} ghosts={:12s} '.format(stype, shape, str(ghosts)+':'), end=' ')
+ print(' DST-{} shape={:12s} ghosts={:12s} '.format(stype, str(shape), str(ghosts)+':'), end=' ')
if (itype==1): # real size will be 2*(N+1)
shape = mk_shape(shape, -1, shape[-1] - 1)
Href = np.random.rand(*shape).astype(dtype).reshape(shape)
@@ -411,7 +411,7 @@ class TestFFT(object):
stype.strip(), itype))
for (shape, cshape, rshape, N, Nc, Nr,
ghosts, mk_buffer) in self.iter_shapes():
- print(' IDST-{} shape={:12s} ghosts={:12s} '.format(stype, shape, str(ghosts)+':'), end=' ')
+ print(' IDST-{} shape={:12s} ghosts={:12s} '.format(stype, str(shape), str(ghosts)+':'), end=' ')
if (iitype==1): # real size will be 2*(N+1)
shape = mk_shape(shape, -1, shape[-1] - 1)
Href = np.random.rand(*shape).astype(dtype).reshape(shape)
@@ -481,7 +481,7 @@ class TestFFT(object):
print('\n C2C-C2C transform')
for (shape, cshape, rshape, N, Nc, Nr,
ghosts, mk_buffer) in self.iter_shapes():
- print(' X - IFFT(FFT(X)) shape={:12s} ghosts={:12s}'.format(shape, str(ghosts)+':'), end=' ')
+ print(' X - IFFT(FFT(X)) shape={:12s} ghosts={:12s}'.format(str(shape), str(ghosts)+':'), end=' ')
Href = np.random.rand(2*N).astype(dtype).view(dtype=ctype).reshape(shape)
results = {}
for (kind, implementations) in self.implementations.items():
@@ -511,7 +511,7 @@ class TestFFT(object):
print('\n R2C-C2R transform')
for (shape, cshape, rshape, N, Nc, Nr,
ghosts, mk_buffer) in self.iter_shapes():
- print(' X - IRFFT(RFFT(X)) shape={:12s} ghosts={:12s} '.format(shape, str(ghosts)+':'), end=' ')
+ print(' X - IRFFT(RFFT(X)) shape={:12s} ghosts={:12s} '.format(str(shape), str(ghosts)+':'), end=' ')
Href = np.random.rand(*shape).astype(dtype).reshape(shape)
results = {}
for (kind, implementations) in self.implementations.items():
@@ -547,7 +547,7 @@ class TestFFT(object):
ttype = 'COS{}'.format(itype)
for (shape, cshape, rshape, N, Nc, Nr,
ghosts, mk_buffer) in self.iter_shapes():
- print(' X - I{}({}(X)) shape={:12s} ghosts={:12s} '.format(ttype, ttype, shape, str(ghosts)+':'), end=' ')
+ print(' X - I{}({}(X)) shape={:12s} ghosts={:12s} '.format(ttype, ttype, str(shape), str(ghosts)+':'), end=' ')
if (itype==1): # real size is 2*(N-1)
shape = mk_shape(shape, -1, shape[-1] + 1)
Href = np.random.rand(*shape).astype(dtype).reshape(shape)
@@ -587,7 +587,8 @@ class TestFFT(object):
ttype = 'SIN{}'.format(itype)
for (shape, cshape, rshape, N, Nc, Nr,
ghosts, mk_buffer) in self.iter_shapes():
- print(' X - I{}({}(X)) shape={:12s} ghosts={:12s} '.format(ttype, ttype, shape, str(ghosts)+':'), end=' ')
+ print(' X - I{}({}(X)) shape={:12s} ghosts={:12s} '.format(ttype, ttype, str(shape), str(ghosts)+':'),
+ end=' ')
if (itype==1): # real size is 2*(N+1)
shape = mk_shape(shape, -1, shape[-1] - 1)
Href = np.random.rand(*shape).astype(dtype).reshape(shape)
diff --git a/hysop/operator/base/custom_symbolic_operator.py b/hysop/operator/base/custom_symbolic_operator.py
index 720ae413f896354f4a99923618517974f4f876b2..5b03ebb86bf00343204e17659dc458cd38ed782c 100644
--- a/hysop/operator/base/custom_symbolic_operator.py
+++ b/hysop/operator/base/custom_symbolic_operator.py
@@ -39,10 +39,14 @@ class ExprDiscretizationInfo(object):
SimpleCounterTypes = (SymbolicArray, SymbolicBuffer,)
IndexedCounterTypes = (DiscreteScalarFieldView,)
- def __init__(self):
+ def __new__(cls, **kwds):
+ return super(ExprDiscretizationInfo, cls).__new__(cls, **kwds)
+
+ def __init__(self, **kwds):
"""
Helper class to store information about discretized symbolic expressions.
"""
+ super(ExprDiscretizationInfo, self).__init__(**kwds)
self.read_counter = SortedDict()
self.write_counter = SortedDict()
self.parameters = SortedDict()
@@ -191,6 +195,11 @@ class ExprDiscretizationInfo(object):
class SymbolicExpressionInfo(object):
"""Helper class store information about parsed symbolic expressions."""
+ def __new__(cls, name, exprs,
+ dt=None, dt_coeff=None,
+ compute_resolution=None, **kwds):
+ return super(SymbolicExpressionInfo, cls).__new__(cls, **kwds)
+
def __init__(self, name, exprs,
dt=None, dt_coeff=None,
compute_resolution=None, **kwds):
@@ -339,7 +348,7 @@ class SymbolicExpressionInfo(object):
if ((k in self.input_dfields) and (self.input_dfields[k].dfield is v.dfield))}
self.stencils = SortedDict()
- dfields = input_dfields.values() + output_dfields.values()
+ dfields = tuple(input_dfields.values()) + tuple(output_dfields.values())
if (force_symbolic_axes is not None):
if isinstance(force_symbolic_axes, tuple):
axes = force_symbolic_axes
@@ -366,7 +375,7 @@ class SymbolicExpressionInfo(object):
SymbolicExpressionParser.setup_expressions(self, work)
def check_dfield_sizes(self):
- dfields = set(f for f in (self.input_dfields.values() + self.output_dfields.values()))
+ dfields = set(self.input_dfields.values()).union(self.output_dfields.values())
if len(dfields)>0:
dfield0 = next(iter(dfields))
compute_resolution = first_not_None(self.compute_resolution, dfield0.compute_resolution)
@@ -1312,6 +1321,22 @@ class CustomSymbolicOperatorBase(DirectionalOperatorBase, metaclass=ABCMeta):
self._expr_info.interpolation = interpolation
self._expr_info.space_discretization = space_discretization
+ @debug
+ def __new__(cls, name, exprs, variables,
+ splitting_direction=None, splitting_dim=None, dt_coeff=None,
+ dt=None, time=None, **kwds):
+ return super(CustomSymbolicOperatorBase, cls).__new__(cls, name=name,
+ input_fields=None,
+ output_fields=None,
+ input_params=None,
+ output_params=None,
+ input_tensor_fields=None,
+ output_tensor_fields=None,
+ splitting_direction=splitting_direction,
+ splitting_dim=splitting_dim,
+ dt_coeff=dt_coeff,
+ **kwds)
+
@debug
def __init__(self, name, exprs, variables,
splitting_direction=None, splitting_dim=None, dt_coeff=None,
diff --git a/hysop/operator/directional/directional.py b/hysop/operator/directional/directional.py
index 26cd6648fe698182d5defd242d2b6fcd5c189cec..56e753349040ddc8a18c4619930a003e5bd50a2a 100644
--- a/hysop/operator/directional/directional.py
+++ b/hysop/operator/directional/directional.py
@@ -12,6 +12,10 @@ class DirectionalOperatorBase(object):
Implementation interface for directional operators.
"""
+ @debug
+ def __new__(cls, splitting_dim, splitting_direction, dt_coeff, **kwds):
+ return super(DirectionalOperatorBase, cls).__new__(cls, **kwds)
+
@debug
def __init__(self, splitting_dim, splitting_direction, dt_coeff, **kwds):
"""
@@ -76,6 +80,9 @@ class DirectionalOperatorBase(object):
return requirements
class DirectionalOperatorGeneratorI(object):
+ def __new__(cls, **kwds):
+ super(DirectionalOperatorGeneratorI, cls).__new__(cls, **kwds)
+
def __init__(self, **kwds):
super(DirectionalOperatorGeneratorI, self).__init__(**kwds)
self._generated = False
@@ -129,6 +136,14 @@ class DirectionalOperatorGenerator(DirectionalOperatorGeneratorI, metaclass=ABCM
multiple directions.
"""
+ @debug
+ def __new__(cls, operator, base_kwds,
+ candidate_input_tensors,
+ candidate_output_tensors,
+ name=None, pretty_name=None,
+ **op_kwds):
+ return super(DirectionalOperatorGenerator, cls).__new__(cls, **base_kwds)
+
@debug
def __init__(self, operator, base_kwds,
candidate_input_tensors,
@@ -158,7 +173,7 @@ class DirectionalOperatorGenerator(DirectionalOperatorGeneratorI, metaclass=ABCM
Output tensor fields that should be rebuilt at discretization.
ScalarFields are filtered out.
"""
- super(DirectionalOperatorGenerator,self).__init__(**base_kwds)
+ super(DirectionalOperatorGenerator, self).__init__(**base_kwds)
candidate_input_tensors = first_not_None(candidate_input_tensors, ())
candidate_output_tensors = first_not_None(candidate_output_tensors, ())
@@ -290,6 +305,11 @@ class DirectionalOperatorFrontend(DirectionalOperatorGenerator, metaclass=ABCMet
multiple implementations.
"""
+ @debug
+ def __new__(cls, implementation=None, base_kwds=None, **op_kwds):
+ return super(DirectionalOperatorFrontend, cls).__new__(cls, operator=None,
+ base_kwds=base_kwds, **op_kwds)
+
@debug
def __init__(self, implementation=None, base_kwds=None, **op_kwds):
"""
diff --git a/hysop/operator/tests/test_analytic.py b/hysop/operator/tests/test_analytic.py
index 755621061903858c0ff21b91a7b725440450f421..5ca022b2ec33c9f90db98e124fec5567dd9199c9 100644
--- a/hysop/operator/tests/test_analytic.py
+++ b/hysop/operator/tests/test_analytic.py
@@ -111,7 +111,7 @@ class TestAnalyticField(object):
domain = Box(length=(1,)*dim)
F = Field(domain=domain, name='F', dtype=dtype,
- nb_components=2, register_object=False)
+ nb_components=2)
self._test_one(shape=shape, dim=dim, dtype=dtype,
domain=domain, F=F)
diff --git a/hysop/parameters/parameter.py b/hysop/parameters/parameter.py
index 74559bdfba02ecaabe206d017e40051e42af060a..499beb96fcebe21685a68032e64da6397a3252cd 100644
--- a/hysop/parameters/parameter.py
+++ b/hysop/parameters/parameter.py
@@ -102,6 +102,13 @@ class Parameter(TaggedObject, VariableTag, metaclass=ABCMeta):
return obj
+ def __init__(self, name, parameter_types,
+ initial_value=None, allow_None=False,
+ quiet=False, const=False,
+ pretty_name=None, var_name=None,
+ is_view=False, **kwds):
+ super(Parameter, self).__init__(tag_prefix='p', variable_kind=Variable.PARAMETER, **kwds)
+
def __eq__(self, other):
return (self is other)
diff --git a/hysop/parameters/scalar_parameter.py b/hysop/parameters/scalar_parameter.py
index ff71bf8a16d18b992df7b70f3b6d9ed7bf83cbc7..d01c60f2df405e4940ecdd490a58953f24cb7bfe 100644
--- a/hysop/parameters/scalar_parameter.py
+++ b/hysop/parameters/scalar_parameter.py
@@ -16,6 +16,9 @@ class ScalarParameter(TensorParameter):
obj = super(ScalarParameter,cls).__new__(cls, name, shape=(1,), **kwds)
return obj
+ def __init__(self, name, **kwds):
+ super(ScalarParameter, self).__init__(name, shape=(1,), **kwds)
+
def iterviews(self):
"""Iterate over all parameters views to yield scalarparameters."""
yield (None,self)
diff --git a/hysop/parameters/tensor_parameter.py b/hysop/parameters/tensor_parameter.py
index 895716d8e4b6b3e5da6c6ff3629d5eb8e7cdc48d..249317b69951ff0b9986c9c198cfd499d06132d3 100644
--- a/hysop/parameters/tensor_parameter.py
+++ b/hysop/parameters/tensor_parameter.py
@@ -113,6 +113,14 @@ class TensorParameter(Parameter):
return obj
+ def __init__(self, name, shape, dtype=HYSOP_REAL,
+ pretty_name=None, initial_value=None,
+ min_value=None, max_value=None, ignore_nans=False, **kwds):
+ super(TensorParameter, self).__init__(
+ name=name, pretty_name=pretty_name,
+ parameter_types=None, allow_None=False,
+ initial_value=initial_value, **kwds)
+
@classmethod
def _compute_initial_value(cls, shape, dtype, initial_value,
min_value=None, max_value=None, ignore_nans=None):
diff --git a/hysop/symbolic/parameter.py b/hysop/symbolic/parameter.py
index 864655071f41b2fa82d626c66c4a5db5dbc9f855..dbc9f8db93a90281ca0f743b15a912be3a5ef052 100644
--- a/hysop/symbolic/parameter.py
+++ b/hysop/symbolic/parameter.py
@@ -22,19 +22,31 @@ class SymbolicTensorParameter(SymbolicTensor):
make_scalar_kwds=make_scalar_kwds,
scalar_kwds=scalar_kwds, **kwds)
+ def __init__(cls, parameter, name=None, pretty_name=None,
+ value=None, shape=None, scalar_cls=None, **kwds):
+ super(SymbolicTensorParameter, self).__init__(
+ name=name, pretty_name=pname,
+ shape=shape, value=value, scalar_cls=scalar_cls,
+ make_scalar_kwds=None,
+ scalar_kwds=None, **kwds)
+
class SymbolicScalarParameter(SymbolicScalar):
def __new__(cls, parameter, name=None, pretty_name=None, value=None, **kwds):
from hysop.parameters.tensor_parameter import TensorParameter
check_instance(parameter, TensorParameter)
value = first_not_None(value, parameter._value)
- name = first_not_None(name, parameter.name)
- pname = first_not_None(pretty_name, parameter.pretty_name)
+ name = first_not_None(name, parameter.name)
+ pname = first_not_None(pretty_name, parameter.pretty_name)
obj = super(SymbolicScalarParameter, cls).__new__(cls,
name=name, pretty_name=pname,
value=value, **kwds)
obj.parameter = parameter
return obj
+ def __init__(self, parameter, name=None, pretty_name=None, value=None, **kwds):
+ super(SymbolicScalarParameter, self).__init__(name=name, pretty_name=pretty_name,
+ value=value, **kwds)
+
if __name__ == '__main__':
from hysop.deps import sm
diff --git a/hysop/tools/cache.py b/hysop/tools/cache.py
index f2b31b24435882c1b1de1f0aca15b7ea18c63d38..c96f4a84dfc0c22c35702e9e1f43961096623af9 100644
--- a/hysop/tools/cache.py
+++ b/hysop/tools/cache.py
@@ -52,7 +52,7 @@ def lock_file(filepath, mode, compressed=True,
def read_only_lock(filepath, compressed=True,
timeout=3600, check_interval=1):
"""Opens a locked read only file, possibly compressed."""
- with lock_file(filepath=filepath, mode='r', compressed=compressed,
+ with lock_file(filepath=filepath, mode='rb', compressed=compressed,
timeout=timeout, check_interval=check_interval) as f:
yield f
@@ -60,7 +60,7 @@ def read_only_lock(filepath, compressed=True,
def write_only_lock(filepath, compressed=True,
timeout=3600, check_interval=1):
"""Opens a locked write only file, possibly compressed."""
- with lock_file(filepath=filepath, mode='w', compressed=compressed,
+ with lock_file(filepath=filepath, mode='wb', compressed=compressed,
timeout=timeout, check_interval=check_interval) as f:
yield f
diff --git a/hysop/tools/handle.py b/hysop/tools/handle.py
index be5f3177211edaa4aa7d1b4cf8472c4efb445f1d..3da4d127edd81061eac0f4a09777b9e08222b36f 100644
--- a/hysop/tools/handle.py
+++ b/hysop/tools/handle.py
@@ -97,7 +97,7 @@ class TaggedObject(object, metaclass=ABCMeta):
tagged_cls = first_not_None(tagged_cls, cls)
if kwds:
- print('TARGGED OBJECT MRO is {}'.format(cls.__mro__))
+ print('TARGGED OBJECT MRO is:\n {}'.format('\n '.join(map(str,cls.__mro__))))
print('KWDS NEW are {}'.format(kwds))
obj = super(TaggedObject, cls).__new__(cls, **kwds)
if tagged_cls in TaggedObject.__ids:
@@ -123,7 +123,7 @@ class TaggedObject(object, metaclass=ABCMeta):
assert (tag_formatter is None) or callable(tag_formatter)
if kwds:
- print('TARGGED OBJECT MRO is {}'.format(self.__class__.__mro__))
+ print('TARGGED OBJECT MRO is:\n {}'.format('\n '.join(map(str,self.__class__.__mro__))))
print('KWDS INIT are {}'.format(kwds))
super(TaggedObject, self).__init__(**kwds)
diff --git a/hysop/tools/io_utils.py b/hysop/tools/io_utils.py
index 58ebce4c254a440539fec994ca39c0e572fcdb4e..dfaf7080a8c1c96a7595985ae06048438509be38 100755
--- a/hysop/tools/io_utils.py
+++ b/hysop/tools/io_utils.py
@@ -51,7 +51,7 @@ class IO(object):
cmd = ['stat', '-f', '-c', '%T', path]
fs_type = ''
if mpi.main_rank == 0:
- fs_type = subprocess.check_output(cmd)
+ fs_type = subprocess.check_output(cmd).decode('utf-8')
fs_type = mpi.main_comm.bcast(fs_type, root=0)
return fs_type.replace('\n', '')
diff --git a/hysop/tools/transposition_states.py b/hysop/tools/transposition_states.py
index 2222e6366ae538310a841e691e312e5b0c23dc7b..79e8c5ab55012a7127d762815ac83a05388d91e7 100644
--- a/hysop/tools/transposition_states.py
+++ b/hysop/tools/transposition_states.py
@@ -55,7 +55,7 @@ class TranspositionStateType(type):
return it.permutations(range(dim), dim)
def __filter_axes(cls, predicate):
"""Return a filtered iterator on all possible permutations."""
- return it.ifilter(predicate, cls.all_axes())
+ return filter(predicate, cls.all_axes())
cls_methods['dimension'] = classmethod(__dimension)
cls_methods['default_axes'] = classmethod(__default_axes)