def get_header(self):
object = self.object
transpiler = OpenCLConverter(known_types=self.known_types)
headers = []
headers.extend(get_code(object.kernel, transpiler))
for equation in object.all_group.equations:
headers.extend(get_code(equation, transpiler))
headers.append(transpiler.parse_instance(object.kernel))
cls_name = object.kernel.__class__.__name__
self.known_types['KERNEL'] = KnownType('__global %s*' % cls_name,
base_type=cls_name)
headers.append(object.all_group.get_equation_wrappers(
self.known_types))
# This is to be done after the above as the equation names are assigned
# only at this point.
cpu_structs = self._cpu_structs
h = CStructHelper(object.kernel)
cpu_structs['kern'] = h.get_array()
for eq in object.all_group.equations:
self._equations[eq.var_name] = eq
h.parse(eq)
cpu_structs[eq.var_name] = h.get_array()
return '\n'.join(headers)
def get_stepper_code(self):
classes = {}
for dest, stepper in self.object.steppers.items():
cls = stepper.__class__.__name__
classes[cls] = stepper
known_types = dict(self.acceleration_eval_helper.known_types)
code_gen = OpenCLConverter(known_types=known_types)
wrappers = []
for cls in sorted(classes.keys()):
wrappers.append(code_gen.parse_instance(classes[cls]))
return '\n'.join(wrappers)
def get_code(obj, transpiler=None):
"""This function looks at the object and gets any additional code to
wrap from the `_get_helpers_` method.
"""
result = []
if hasattr(obj, '_get_helpers_'):
if transpiler is None:
transpiler = OpenCLConverter()
doc = '\n// Helpers from %s' % obj.__class__.__name__
result.append(doc)
for helper in obj._get_helpers_():
result.append(transpiler.parse_function(helper))
return result
def test_opencl_class():
src = dedent('''
class Foo(object):
def g(self, x=0.0):
pass
''')
# When
converter = OpenCLConverter()
code = converter.convert(src)
# Then
expect = dedent('''
void Foo_g(__global Foo* self, double x)
{
;
}
''')
assert code.strip() == expect.strip()
def test_opencl_conversion():
src = dedent('''
def f(s_idx, s_p, d_idx, d_p, J=0, t=0.0, l=[0,0], xx=(0, 0)):
pass
''')
# When
known_types = {'d_p': KnownType('__global int*')}
converter = OpenCLConverter(known_types=known_types)
code = converter.convert(src)
# Then
expect = dedent('''
void f(long s_idx, __global double* s_p, long d_idx, __global int* d_p, long
J, double t, double* l, double* xx)
{
;
}
''')
assert code.strip() == expect.strip()
def get_equation_wrappers(self, known_types={}):
classes = defaultdict(lambda: 0)
eqs = {}
for equation in self.equations:
cls = equation.__class__.__name__
n = classes[cls]
equation.var_name = '%s%d' % (
camel_to_underscore(equation.name), n
)
classes[cls] += 1
eqs[cls] = equation
wrappers = []
predefined = dict(get_predefined_types(self.pre_comp))
predefined.update(known_types)
code_gen = OpenCLConverter(known_types=predefined)
ignore = ['reduce']
for cls in sorted(classes.keys()):
src = code_gen.parse_instance(eqs[cls], ignore_methods=ignore)
wrappers.append(src)
return '\n'.join(wrappers)