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_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)