def create_codeobj(self, name, abstract_code, specs, template_method,
additional_namespace={}):
lang = self.language
logger.debug("NeuronGroup "+name+" abstract code:\n"+abstract_code)
innercode = translate(abstract_code, specs,
brian_prefs.default_scalar_dtype,
lang)
logger.debug("NeuronGroup "+name+" inner code:\n"+str(innercode))
code = lang.apply_template(innercode, template_method())
logger.debug("NeuronGroup "+name+" code:\n"+str(code))
codeobj = lang.code_object(code, specs)
namespace = {}
for name, arr in self.arrays.iteritems():
namespace['_array_'+name] = arr
if not hasattr(self, 'namespace'):
self.namespace = namespace
self.namespace.update(**additional_namespace)
self.namespace['_num_neurons'] = self.N
self.namespace['dt'] = self.clock.dt_
self.namespace['t'] = self.clock.t_
codeobj.compile(self.namespace)
return codeobj
return cls(*args, **kwds)
except Exception as e:
warnings.warn("Couldn't load language "+cls.__name__+'\n'+str(e))
return None
languages = [lang for lang in [
getlang(PythonLanguage),
getlang(NumexprPythonLanguage),
getlang(CPPLanguage, extra_compile_args=['-O3', '-ffast-math', '-march=native'], restrict='__restrict__', flush_denormals=True),
#getlang(CUDALanguage),
] if lang is not None]
codestrings = {}
for lang in languages:
innercode = translate(G.abstract_code, G.specifiers, float64, lang)
code = lang.apply_template(innercode, lang.template_state_update())
codestrings[lang] = code
print lang.__class__.__name__
print '='*len(lang.__class__.__name__)
codeprint(code)
if not test_compile:
exit()
N = 100000
Nshow = 10
tshow = 100
ttest = 1000
dt = 0.001
_array_V = pylab.rand(N)
abstract = """
V += w
"""
specifiers = {
"V": ArrayVariable("_array_V", "_postsynaptic_idx", float64),
"w": ArrayVariable("_array_w", "_synapse_idx", float64),
"_spiking_synapse_idx": Index(),
"_postsynaptic_idx": Index(all=False),
"_synapse_idx": Index(all=False),
"_presynaptic_idx": Index(all=False),
}
intermediate = make_statements(abstract, specifiers, float64)
print "ABSTRACT CODE:"
print abstract
print "INTERMEDIATE STATEMENTS:"
print
for stmt in intermediate:
print stmt
print
for lang in [PythonLanguage(), CPPLanguage()]:
innercode = translate(abstract, specifiers, float64, lang)
code = lang.apply_template(innercode, lang.template_synapses())
print lang.__class__.__name__
print "=" * len(lang.__class__.__name__)
codeprint(code)
def code_object(self, owner, name, abstract_code, variables, template_name,
variable_indices, codeobj_class=None,
template_kwds=None):
codeobj_class = self.code_object_class(codeobj_class)
language = codeobj_class.language
if template_kwds is None:
template_kwds = dict()
else:
template_kwds = template_kwds.copy()
template = getattr(codeobj_class.templater, template_name)
# Check that all functions are available
for varname, value in variables.iteritems():
if isinstance(value, Function):
try:
value.implementations[codeobj_class]
except KeyError as ex:
# if we are dealing with numpy, add the default implementation
if codeobj_class is NumpyCodeObject:
add_numpy_implementation(value, value.pyfunc)
else:
raise NotImplementedError(('Cannot use function '
'%s: %s') % (varname, ex))
if isinstance(abstract_code, dict):
for k, v in abstract_code.items():
logger.debug('%s abstract code key %s:\n%s' % (name, k, v))
else:
logger.debug(name + " abstract code:\n" + abstract_code)
iterate_all = template.iterate_all
snippet, kwds = translate(abstract_code, variables,
dtype=brian_prefs['core.default_scalar_dtype'],
codeobj_class=codeobj_class,
variable_indices=variable_indices,
iterate_all=iterate_all)
# Add the array names as keywords as well
for varname, var in variables.iteritems():
if isinstance(var, ArrayVariable):
pointer_name = language.get_array_name(var)
template_kwds[varname] = pointer_name
if hasattr(var, 'resize'):
dyn_array_name = language.get_array_name(var,
access_data=False)
template_kwds['_dynamic_'+varname] = dyn_array_name
template_kwds.update(kwds)
logger.debug(name + " snippet:\n" + str(snippet))
name = find_name(name)
code = template(snippet,
owner=owner, variables=variables, codeobj_name=name,
variable_indices=variable_indices,
get_array_name=language.get_array_name,
**template_kwds)
logger.debug(name + " code:\n" + str(code))
codeobj = codeobj_class(owner, code, variables, name=name)
codeobj.compile()
return codeobj
