def build(self,
directory='output',
compile=True,
run=True,
debug=False,
clean=True,
with_output=True,
native=True,
additional_source_files=None,
run_args=None,
**kwds):
'''
Build the project
TODO: more details
Parameters
----------
directory : str
The output directory to write the project to, any existing files will be overwritten.
compile : bool
Whether or not to attempt to compile the project
run : bool
Whether or not to attempt to run the built project if it successfully builds.
debug : bool
Whether to compile in debug mode.
with_output : bool
Whether or not to show the ``stdout`` of the built program when run.
native : bool
Whether or not to compile for the current machine's architecture (best for speed, but not portable)
clean : bool
Whether or not to clean the project before building
additional_source_files : list of str
A list of additional ``.cpp`` files to include in the build.
'''
renames = {
'project_dir': 'directory',
'compile_project': 'compile',
'run_project': 'run'
}
if len(kwds):
msg = ''
for kwd in kwds:
if kwd in renames:
msg += ("Keyword argument '%s' has been renamed to "
"'%s'. ") % (kwd, renames[kwd])
else:
msg += "Unknown keyword argument '%s'. " % kwd
raise TypeError(msg)
if additional_source_files is None:
additional_source_files = []
if run_args is None:
run_args = []
self.project_dir = directory
ensure_directory(directory)
compiler, extra_compile_args = get_compiler_and_args()
compiler_obj = ccompiler.new_compiler(compiler=compiler)
compiler_flags = (ccompiler.gen_preprocess_options(
prefs['codegen.cpp.define_macros'],
prefs['codegen.cpp.include_dirs']) + extra_compile_args)
linker_flags = (ccompiler.gen_lib_options(
compiler_obj,
library_dirs=prefs['codegen.cpp.library_dirs'],
runtime_library_dirs=prefs['codegen.cpp.runtime_library_dirs'],
libraries=prefs['codegen.cpp.libraries']) +
prefs['codegen.cpp.extra_link_args'])
for d in ['code_objects', 'results', 'static_arrays']:
ensure_directory(os.path.join(directory, d))
writer = CPPWriter(directory)
# Get the number of threads if specified in an openmp context
nb_threads = prefs.devices.cpp_standalone.openmp_threads
# If the number is negative, we need to throw an error
if (nb_threads < 0):
raise ValueError(
'The number of OpenMP threads can not be negative !')
logger.debug("Writing C++ standalone project to directory " +
os.path.normpath(directory))
self.check_openmp_compatible(nb_threads)
arange_arrays = sorted(
[(var, start) for var, start in self.arange_arrays.iteritems()],
key=lambda (var, start): var.name)
self.write_static_arrays(directory)
self.find_synapses()
# Not sure what the best place is to call Network.after_run -- at the
# moment the only important thing it does is to clear the objects stored
# in magic_network. If this is not done, this might lead to problems
# for repeated runs of standalone (e.g. in the test suite).
for net in self.networks:
net.after_run()
# Check that all names are globally unique
names = [obj.name for net in self.networks for obj in net.objects]
non_unique_names = [
name for name, count in Counter(names).iteritems() if count > 1
]
if len(non_unique_names):
formatted_names = ', '.join("'%s'" % name
for name in non_unique_names)
raise ValueError(
'All objects need to have unique names in '
'standalone mode, the following name(s) were used '
'more than once: %s' % formatted_names)
self.generate_objects_source(writer, arange_arrays, self.net_synapses,
self.static_array_specs, self.networks)
self.generate_main_source(writer)
self.generate_codeobj_source(writer)
self.generate_network_source(writer, compiler)
self.generate_synapses_classes_source(writer)
self.generate_run_source(writer)
self.copy_source_files(writer, directory)
writer.source_files.extend(additional_source_files)
self.generate_makefile(writer,
compiler,
native=native,
compiler_flags=' '.join(compiler_flags),
linker_flags=' '.join(linker_flags),
nb_threads=nb_threads)
if compile:
self.compile_source(directory, compiler, debug, clean, native)
if run:
self.run(directory, with_output, run_args)
def build(self, directory='output',
compile=True, run=True, debug=False, clean=True,
with_output=True, native=True,
additional_source_files=None, additional_header_files=None,
main_includes=None, run_includes=None,
run_args=None, **kwds):
'''
Build the project
TODO: more details
Parameters
----------
directory : str
The output directory to write the project to, any existing files will be overwritten.
compile : bool
Whether or not to attempt to compile the project
run : bool
Whether or not to attempt to run the built project if it successfully builds.
debug : bool
Whether to compile in debug mode.
with_output : bool
Whether or not to show the ``stdout`` of the built program when run.
native : bool
Whether or not to compile for the current machine's architecture (best for speed, but not portable)
clean : bool
Whether or not to clean the project before building
additional_source_files : list of str
A list of additional ``.cpp`` files to include in the build.
additional_header_files : list of str
A list of additional ``.h`` files to include in the build.
main_includes : list of str
A list of additional header files to include in ``main.cpp``.
run_includes : list of str
A list of additional header files to include in ``run.cpp``.
'''
renames = {'project_dir': 'directory',
'compile_project': 'compile',
'run_project': 'run'}
if len(kwds):
msg = ''
for kwd in kwds:
if kwd in renames:
msg += ("Keyword argument '%s' has been renamed to "
"'%s'. ") % (kwd, renames[kwd])
else:
msg += "Unknown keyword argument '%s'. " % kwd
raise TypeError(msg)
if additional_source_files is None:
additional_source_files = []
if additional_header_files is None:
additional_header_files = []
if main_includes is None:
main_includes = []
if run_includes is None:
run_includes = []
if run_args is None:
run_args = []
compiler, extra_compile_args = get_compiler_and_args()
compiler_flags = ' '.join(extra_compile_args)
self.project_dir = directory
ensure_directory(directory)
for d in ['code_objects', 'results', 'static_arrays']:
ensure_directory(os.path.join(directory, d))
writer = CUDAWriter(directory)
logger.debug("Writing CUDA standalone project to directory "+os.path.normpath(directory))
arange_arrays = sorted([(var, start)
for var, start in self.arange_arrays.iteritems()],
key=lambda (var, start): var.name)
self.write_static_arrays(directory)
self.find_synapses()
# Not sure what the best place is to call Network.after_run -- at the
# moment the only important thing it does is to clear the objects stored
# in magic_network. If this is not done, this might lead to problems
# for repeated runs of standalone (e.g. in the test suite).
for net in self.networks:
net.after_run()
self.generate_main_source(writer, main_includes)
self.generate_codeobj_source(writer)
self.generate_objects_source(writer, arange_arrays, self.net_synapses, self.static_array_specs, self.networks)
self.generate_network_source(writer, compiler)
self.generate_synapses_classes_source(writer)
self.generate_run_source(writer, run_includes)
self.generate_rand_source(writer)
self.copy_source_files(writer, directory)
writer.source_files.extend(additional_source_files)
writer.header_files.extend(additional_header_files)
self.generate_makefile(writer, compiler, native, compiler_flags, nb_threads=0)
if compile:
self.compile_source(directory, compiler, debug, clean, native)
if run:
self.run(directory, with_output, run_args)
def build(self, directory='output',
compile=True, run=True, debug=False, clean=True,
with_output=True, native=True,
additional_source_files=None,
run_args=None, **kwds):
'''
Build the project
TODO: more details
Parameters
----------
directory : str
The output directory to write the project to, any existing files will be overwritten.
compile : bool
Whether or not to attempt to compile the project
run : bool
Whether or not to attempt to run the built project if it successfully builds.
debug : bool
Whether to compile in debug mode.
with_output : bool
Whether or not to show the ``stdout`` of the built program when run. Output will be shown in case
of compilation or runtime error.
native : bool
Whether or not to compile for the current machine's architecture (best for speed, but not portable)
clean : bool
Whether or not to clean the project before building
additional_source_files : list of str
A list of additional ``.cpp`` files to include in the build.
'''
renames = {'project_dir': 'directory',
'compile_project': 'compile',
'run_project': 'run'}
if len(kwds):
msg = ''
for kwd in kwds:
if kwd in renames:
msg += ("Keyword argument '%s' has been renamed to "
"'%s'. ") % (kwd, renames[kwd])
else:
msg += "Unknown keyword argument '%s'. " % kwd
raise TypeError(msg)
if additional_source_files is None:
additional_source_files = []
if run_args is None:
run_args = []
self.project_dir = directory
ensure_directory(directory)
compiler, extra_compile_args = get_compiler_and_args()
compiler_obj = ccompiler.new_compiler(compiler=compiler)
compiler_flags = (ccompiler.gen_preprocess_options(prefs['codegen.cpp.define_macros'],
prefs['codegen.cpp.include_dirs']) +
extra_compile_args)
linker_flags = (ccompiler.gen_lib_options(compiler_obj,
library_dirs=prefs['codegen.cpp.library_dirs'],
runtime_library_dirs=prefs['codegen.cpp.runtime_library_dirs'],
libraries=prefs['codegen.cpp.libraries']) +
prefs['codegen.cpp.extra_link_args'])
for d in ['code_objects', 'results', 'static_arrays']:
ensure_directory(os.path.join(directory, d))
writer = CPPWriter(directory)
# Get the number of threads if specified in an openmp context
nb_threads = prefs.devices.cpp_standalone.openmp_threads
# If the number is negative, we need to throw an error
if (nb_threads < 0):
raise ValueError('The number of OpenMP threads can not be negative !')
logger.debug("Writing C++ standalone project to directory "+os.path.normpath(directory))
self.check_openmp_compatible(nb_threads)
arange_arrays = sorted([(var, start)
for var, start in self.arange_arrays.iteritems()],
key=lambda (var, start): var.name)
self.write_static_arrays(directory)
self.find_synapses()
# Not sure what the best place is to call Network.after_run -- at the
# moment the only important thing it does is to clear the objects stored
# in magic_network. If this is not done, this might lead to problems
# for repeated runs of standalone (e.g. in the test suite).
for net in self.networks:
net.after_run()
# Check that all names are globally unique
names = [obj.name for net in self.networks for obj in net.objects]
non_unique_names = [name for name, count in Counter(names).iteritems()
if count > 1]
if len(non_unique_names):
formatted_names = ', '.join("'%s'" % name
for name in non_unique_names)
raise ValueError('All objects need to have unique names in '
'standalone mode, the following name(s) were used '
'more than once: %s' % formatted_names)
self.generate_objects_source(writer, arange_arrays, self.net_synapses, self.static_array_specs, self.networks)
self.generate_main_source(writer)
self.generate_codeobj_source(writer)
self.generate_network_source(writer, compiler)
self.generate_synapses_classes_source(writer)
self.generate_run_source(writer)
self.copy_source_files(writer, directory)
writer.source_files.extend(additional_source_files)
self.generate_makefile(writer, compiler, native=native,
compiler_flags=' '.join(compiler_flags),
linker_flags=' '.join(linker_flags),
nb_threads=nb_threads)
if compile:
self.compile_source(directory, compiler, debug, clean, native)
if run:
self.run(directory, with_output, run_args)
def build(
self,
project_dir='output',
compile_project=True,
run_project=False,
debug=True,
with_output=True,
native=True,
additional_source_files=None,
additional_header_files=None,
main_includes=None,
run_includes=None,
run_args=None,
):
'''
Build the project
TODO: more details
Parameters
----------
project_dir : str
The output directory to write the project to, any existing files will be overwritten.
compile_project : bool
Whether or not to attempt to compile the project using GNU make.
run_project : bool
Whether or not to attempt to run the built project if it successfully builds.
debug : bool
Whether to compile in debug mode.
with_output : bool
Whether or not to show the ``stdout`` of the built program when run.
native : bool
Whether or not to compile natively using the ``--march=native`` gcc option.
additional_source_files : list of str
A list of additional ``.cpp`` files to include in the build.
additional_header_files : list of str
A list of additional ``.h`` files to include in the build.
main_includes : list of str
A list of additional header files to include in ``main.cpp``.
run_includes : list of str
A list of additional header files to include in ``run.cpp``.
'''
if additional_source_files is None:
additional_source_files = []
if additional_header_files is None:
additional_header_files = []
if main_includes is None:
main_includes = []
if run_includes is None:
run_includes = []
if run_args is None:
run_args = []
self.project_dir = project_dir
ensure_directory(project_dir)
for d in ['code_objects', 'results', 'static_arrays']:
ensure_directory(os.path.join(project_dir, d))
writer = CPPWriter(project_dir)
logger.debug("Writing C++ standalone project to directory " +
os.path.normpath(project_dir))
arange_arrays = sorted(
[(var, start) for var, start in self.arange_arrays.iteritems()],
key=lambda (var, start): var.name)
# # Find np arrays in the namespaces and convert them into static
# # arrays. Hopefully they are correctly used in the code: For example,
# # this works for the namespaces for functions with C++ (e.g. TimedArray
# # treats it as a C array) but does not work in places that are
# # implicitly vectorized (state updaters, resets, etc.). But arrays
# # shouldn't be used there anyway.
for code_object in self.code_objects.itervalues():
for name, value in code_object.variables.iteritems():
if isinstance(value, np.ndarray):
self.static_arrays[name] = value
# write the static arrays
logger.debug("static arrays: " +
str(sorted(self.static_arrays.keys())))
static_array_specs = []
for name, arr in sorted(self.static_arrays.items()):
arr.tofile(os.path.join(project_dir, 'static_arrays', name))
static_array_specs.append(
(name, c_data_type(arr.dtype), arr.size, name))
# Write the global objects
networks = [
net() for net in Network.__instances__()
if net().name != '_fake_network'
]
synapses = [S() for S in Synapses.__instances__()]
arr_tmp = CPPStandaloneCodeObject.templater.objects(
None,
None,
array_specs=self.arrays,
dynamic_array_specs=self.dynamic_arrays,
dynamic_array_2d_specs=self.dynamic_arrays_2d,
zero_arrays=self.zero_arrays,
arange_arrays=arange_arrays,
synapses=synapses,
clocks=self.clocks,
static_array_specs=static_array_specs,
networks=networks,
)
writer.write('objects.*', arr_tmp)
main_lines = []
procedures = [('', main_lines)]
runfuncs = {}
for func, args in self.main_queue:
if func == 'run_code_object':
codeobj, = args
main_lines.append('_run_%s();' % codeobj.name)
elif func == 'run_network':
net, netcode = args
main_lines.extend(netcode)
elif func == 'set_by_array':
arrayname, staticarrayname = args
code = '''
for(int i=0; i<_num_{staticarrayname}; i++)
{{
{arrayname}[i] = {staticarrayname}[i];
}}
'''.format(arrayname=arrayname,
staticarrayname=staticarrayname)
main_lines.extend(code.split('\n'))
elif func == 'set_array_by_array':
arrayname, staticarrayname_index, staticarrayname_value = args
code = '''
for(int i=0; i<_num_{staticarrayname_index}; i++)
{{
{arrayname}[{staticarrayname_index}[i]] = {staticarrayname_value}[i];
}}
'''.format(arrayname=arrayname,
staticarrayname_index=staticarrayname_index,
staticarrayname_value=staticarrayname_value)
main_lines.extend(code.split('\n'))
elif func == 'insert_code':
main_lines.append(args)
elif func == 'start_run_func':
name, include_in_parent = args
if include_in_parent:
main_lines.append('%s();' % name)
main_lines = []
procedures.append((name, main_lines))
elif func == 'end_run_func':
name, include_in_parent = args
name, main_lines = procedures.pop(-1)
runfuncs[name] = main_lines
name, main_lines = procedures[-1]
else:
raise NotImplementedError("Unknown main queue function type " +
func)
# generate the finalisations
for codeobj in self.code_objects.itervalues():
if hasattr(codeobj.code, 'main_finalise'):
main_lines.append(codeobj.code.main_finalise)
# Generate data for non-constant values
code_object_defs = defaultdict(list)
for codeobj in self.code_objects.itervalues():
lines = []
for k, v in codeobj.variables.iteritems():
if isinstance(v, AttributeVariable):
# We assume all attributes are implemented as property-like methods
line = 'const {c_type} {varname} = {objname}.{attrname}();'
lines.append(
line.format(c_type=c_data_type(v.dtype),
varname=k,
objname=v.obj.name,
attrname=v.attribute))
elif isinstance(v, ArrayVariable):
try:
if isinstance(v, DynamicArrayVariable):
if v.dimensions == 1:
dyn_array_name = self.dynamic_arrays[v]
array_name = self.arrays[v]
line = '{c_type}* const {array_name} = &{dyn_array_name}[0];'
line = line.format(
c_type=c_data_type(v.dtype),
array_name=array_name,
dyn_array_name=dyn_array_name)
lines.append(line)
line = 'const int _num{k} = {dyn_array_name}.size();'
line = line.format(
k=k, dyn_array_name=dyn_array_name)
lines.append(line)
else:
lines.append('const int _num%s = %s;' %
(k, v.size))
except TypeError:
pass
for line in lines:
# Sometimes an array is referred to by to different keys in our
# dictionary -- make sure to never add a line twice
if not line in code_object_defs[codeobj.name]:
code_object_defs[codeobj.name].append(line)
# Generate the code objects
for codeobj in self.code_objects.itervalues():
ns = codeobj.variables
# TODO: fix these freeze/CONSTANTS hacks somehow - they work but not elegant.
code = freeze(codeobj.code.cpp_file, ns)
code = code.replace('%CONSTANTS%',
'\n'.join(code_object_defs[codeobj.name]))
code = '#include "objects.h"\n' + code
writer.write('code_objects/' + codeobj.name + '.cpp', code)
writer.write('code_objects/' + codeobj.name + '.h',
codeobj.code.h_file)
# The code_objects are passed in the right order to run them because they were
# sorted by the Network object. To support multiple clocks we'll need to be
# smarter about that.
main_tmp = CPPStandaloneCodeObject.templater.main(
None,
None,
main_lines=main_lines,
code_objects=self.code_objects.values(),
report_func=self.report_func,
dt=float(defaultclock.dt),
additional_headers=main_includes,
)
writer.write('main.cpp', main_tmp)
# Generate the run functions
run_tmp = CPPStandaloneCodeObject.templater.run(
None,
None,
run_funcs=runfuncs,
code_objects=self.code_objects.values(),
additional_headers=run_includes,
)
writer.write('run.*', run_tmp)
# Copy the brianlibdirectory
brianlib_dir = os.path.join(
os.path.split(inspect.getsourcefile(CPPStandaloneCodeObject))[0],
'brianlib')
brianlib_files = copy_directory(brianlib_dir,
os.path.join(project_dir, 'brianlib'))
for file in brianlib_files:
if file.lower().endswith('.cpp'):
writer.source_files.append('brianlib/' + file)
elif file.lower().endswith('.h'):
writer.header_files.append('brianlib/' + file)
# Copy the CSpikeQueue implementation
spikequeue_h = os.path.join(project_dir, 'brianlib', 'spikequeue.h')
shutil.copy2(
os.path.join(
os.path.split(inspect.getsourcefile(Synapses))[0],
'cspikequeue.cpp'), spikequeue_h)
#writer.header_files.append(spikequeue_h)
writer.source_files.extend(additional_source_files)
writer.header_files.extend(additional_header_files)
# Generate the makefile
if os.name == 'nt':
rm_cmd = 'del'
else:
rm_cmd = 'rm'
makefile_tmp = CPPStandaloneCodeObject.templater.makefile(
None,
None,
source_files=' '.join(writer.source_files),
header_files=' '.join(writer.header_files),
rm_cmd=rm_cmd)
writer.write('makefile', makefile_tmp)
# build the project
if compile_project:
with in_directory(project_dir):
if debug:
x = os.system('make debug')
elif native:
x = os.system('make native')
else:
x = os.system('make')
if x == 0:
if run_project:
if not with_output:
stdout = open(os.devnull, 'w')
else:
stdout = None
if os.name == 'nt':
x = subprocess.call(['main'] + run_args,
stdout=stdout)
else:
x = subprocess.call(['./main'] + run_args,
stdout=stdout)
if x:
raise RuntimeError("Project run failed")
self.has_been_run = True
else:
raise RuntimeError("Project compilation failed")
def build(self,
directory='output',
compile=True,
run=True,
debug=False,
clean=True,
with_output=True,
additional_source_files=None,
additional_header_files=None,
main_includes=None,
run_includes=None,
run_args=None,
direct_call=True,
**kwds):
'''
Build the project
TODO: more details
Parameters
----------
directory : str, optional
The output directory to write the project to, any existing files
will be overwritten. If the given directory name is ``None``, then
a temporary directory will be used (used in the test suite to avoid
problems when running several tests in parallel). Defaults to
``'output'``.
compile : bool, optional
Whether or not to attempt to compile the project. Defaults to
``True``.
run : bool, optional
Whether or not to attempt to run the built project if it
successfully builds. Defaults to ``True``.
debug : bool, optional
Whether to compile in debug mode. Defaults to ``False``.
with_output : bool, optional
Whether or not to show the ``stdout`` of the built program when run.
Output will be shown in case of compilation or runtime error.
Defaults to ``True``.
clean : bool, optional
Whether or not to clean the project before building. Defaults to
``True``.
additional_source_files : list of str, optional
A list of additional ``.cu`` files to include in the build.
additional_header_files : list of str
A list of additional ``.h`` files to include in the build.
main_includes : list of str
A list of additional header files to include in ``main.cu``.
run_includes : list of str
A list of additional header files to include in ``run.cu``.
direct_call : bool, optional
Whether this function was called directly. Is used internally to
distinguish an automatic build due to the ``build_on_run`` option
from a manual ``device.build`` call.
'''
if self.build_on_run and direct_call:
raise RuntimeError(
'You used set_device with build_on_run=True '
'(the default option), which will automatically '
'build the simulation at the first encountered '
'run call - do not call device.build manually '
'in this case. If you want to call it manually, '
'e.g. because you have multiple run calls, use '
'set_device with build_on_run=False.')
if self.has_been_run:
raise RuntimeError('The network has already been built and run '
'before. To build several simulations in '
'the same script, call "device.reinit()" '
'and "device.activate()". Note that you '
'will have to set build options (e.g. the '
'directory) and defaultclock.dt again.')
renames = {
'project_dir': 'directory',
'compile_project': 'compile',
'run_project': 'run'
}
if len(kwds):
msg = ''
for kwd in kwds:
if kwd in renames:
msg += ("Keyword argument '%s' has been renamed to "
"'%s'. ") % (kwd, renames[kwd])
else:
msg += "Unknown keyword argument '%s'. " % kwd
raise TypeError(msg)
if additional_source_files is None:
additional_source_files = []
if additional_header_files is None:
additional_header_files = []
if main_includes is None:
main_includes = []
if run_includes is None:
run_includes = []
if run_args is None:
run_args = []
if directory is None:
directory = tempfile.mkdtemp()
cpp_compiler, cpp_extra_compile_args = get_compiler_and_args()
cpp_compiler_flags = ' '.join(cpp_extra_compile_args)
self.project_dir = directory
ensure_directory(directory)
for d in ['code_objects', 'results', 'static_arrays']:
ensure_directory(os.path.join(directory, d))
writer = CUDAWriter(directory)
logger.diagnostic("Writing CUDA standalone project to directory " +
os.path.normpath(directory))
arange_arrays = sorted(
[(var, start) for var, start in self.arange_arrays.iteritems()],
key=lambda (var, start): var.name)
self.write_static_arrays(directory)
self.find_synapses()
# Not sure what the best place is to call Network.after_run -- at the
# moment the only important thing it does is to clear the objects stored
# in magic_network. If this is not done, this might lead to problems
# for repeated runs of standalone (e.g. in the test suite).
for net in self.networks:
net.after_run()
self.generate_main_source(writer, main_includes)
self.generate_codeobj_source(writer)
self.generate_objects_source(writer, arange_arrays, self.net_synapses,
self.static_array_specs, self.networks)
self.generate_network_source(writer)
self.generate_synapses_classes_source(writer)
self.generate_run_source(writer, run_includes)
self.generate_rand_source(writer)
self.copy_source_files(writer, directory)
writer.source_files.extend(additional_source_files)
writer.header_files.extend(additional_header_files)
self.generate_makefile(writer,
cpp_compiler,
cpp_compiler_flags,
nb_threads=0)
if compile:
self.compile_source(directory, cpp_compiler, debug, clean)
if run:
self.run(directory, with_output, run_args)
def build(self, project_dir='output', compile_project=True, run_project=False, debug=True,
with_output=True, native=True,
additional_source_files=None, additional_header_files=None,
main_includes=None, run_includes=None,
run_args=None,
):
'''
Build the project
TODO: more details
Parameters
----------
project_dir : str
The output directory to write the project to, any existing files will be overwritten.
compile_project : bool
Whether or not to attempt to compile the project using GNU make.
run_project : bool
Whether or not to attempt to run the built project if it successfully builds.
debug : bool
Whether to compile in debug mode.
with_output : bool
Whether or not to show the ``stdout`` of the built program when run.
native : bool
Whether or not to compile natively using the ``--march=native`` gcc option.
additional_source_files : list of str
A list of additional ``.cpp`` files to include in the build.
additional_header_files : list of str
A list of additional ``.h`` files to include in the build.
main_includes : list of str
A list of additional header files to include in ``main.cpp``.
run_includes : list of str
A list of additional header files to include in ``run.cpp``.
'''
if additional_source_files is None:
additional_source_files = []
if additional_header_files is None:
additional_header_files = []
if main_includes is None:
main_includes = []
if run_includes is None:
run_includes = []
if run_args is None:
run_args = []
self.project_dir = project_dir
ensure_directory(project_dir)
for d in ['code_objects', 'results', 'static_arrays']:
ensure_directory(os.path.join(project_dir, d))
writer = CPPWriter(project_dir)
logger.debug("Writing C++ standalone project to directory "+os.path.normpath(project_dir))
arange_arrays = sorted([(var, start)
for var, start in self.arange_arrays.iteritems()],
key=lambda (var, start): var.name)
# # Find np arrays in the namespaces and convert them into static
# # arrays. Hopefully they are correctly used in the code: For example,
# # this works for the namespaces for functions with C++ (e.g. TimedArray
# # treats it as a C array) but does not work in places that are
# # implicitly vectorized (state updaters, resets, etc.). But arrays
# # shouldn't be used there anyway.
for code_object in self.code_objects.itervalues():
for name, value in code_object.variables.iteritems():
if isinstance(value, np.ndarray):
self.static_arrays[name] = value
# write the static arrays
logger.debug("static arrays: "+str(sorted(self.static_arrays.keys())))
static_array_specs = []
for name, arr in sorted(self.static_arrays.items()):
arr.tofile(os.path.join(project_dir, 'static_arrays', name))
static_array_specs.append((name, c_data_type(arr.dtype), arr.size, name))
# Write the global objects
networks = [net() for net in Network.__instances__() if net().name!='_fake_network']
synapses = [S() for S in Synapses.__instances__()]
arr_tmp = CPPStandaloneCodeObject.templater.objects(
None, None,
array_specs=self.arrays,
dynamic_array_specs=self.dynamic_arrays,
dynamic_array_2d_specs=self.dynamic_arrays_2d,
zero_arrays=self.zero_arrays,
arange_arrays=arange_arrays,
synapses=synapses,
clocks=self.clocks,
static_array_specs=static_array_specs,
networks=networks,
)
writer.write('objects.*', arr_tmp)
main_lines = []
procedures = [('', main_lines)]
runfuncs = {}
for func, args in self.main_queue:
if func=='run_code_object':
codeobj, = args
main_lines.append('_run_%s();' % codeobj.name)
elif func=='run_network':
net, netcode = args
main_lines.extend(netcode)
elif func=='set_by_array':
arrayname, staticarrayname = args
code = '''
for(int i=0; i<_num_{staticarrayname}; i++)
{{
{arrayname}[i] = {staticarrayname}[i];
}}
'''.format(arrayname=arrayname, staticarrayname=staticarrayname)
main_lines.extend(code.split('\n'))
elif func=='set_array_by_array':
arrayname, staticarrayname_index, staticarrayname_value = args
code = '''
for(int i=0; i<_num_{staticarrayname_index}; i++)
{{
{arrayname}[{staticarrayname_index}[i]] = {staticarrayname_value}[i];
}}
'''.format(arrayname=arrayname, staticarrayname_index=staticarrayname_index,
staticarrayname_value=staticarrayname_value)
main_lines.extend(code.split('\n'))
elif func=='insert_code':
main_lines.append(args)
elif func=='start_run_func':
name, include_in_parent = args
if include_in_parent:
main_lines.append('%s();' % name)
main_lines = []
procedures.append((name, main_lines))
elif func=='end_run_func':
name, include_in_parent = args
name, main_lines = procedures.pop(-1)
runfuncs[name] = main_lines
name, main_lines = procedures[-1]
else:
raise NotImplementedError("Unknown main queue function type "+func)
# generate the finalisations
for codeobj in self.code_objects.itervalues():
if hasattr(codeobj.code, 'main_finalise'):
main_lines.append(codeobj.code.main_finalise)
# Generate data for non-constant values
code_object_defs = defaultdict(list)
for codeobj in self.code_objects.itervalues():
lines = []
for k, v in codeobj.variables.iteritems():
if isinstance(v, AttributeVariable):
# We assume all attributes are implemented as property-like methods
line = 'const {c_type} {varname} = {objname}.{attrname}();'
lines.append(line.format(c_type=c_data_type(v.dtype), varname=k, objname=v.obj.name,
attrname=v.attribute))
elif isinstance(v, ArrayVariable):
try:
if isinstance(v, DynamicArrayVariable):
if v.dimensions == 1:
dyn_array_name = self.dynamic_arrays[v]
array_name = self.arrays[v]
line = '{c_type}* const {array_name} = &{dyn_array_name}[0];'
line = line.format(c_type=c_data_type(v.dtype), array_name=array_name,
dyn_array_name=dyn_array_name)
lines.append(line)
line = 'const int _num{k} = {dyn_array_name}.size();'
line = line.format(k=k, dyn_array_name=dyn_array_name)
lines.append(line)
else:
lines.append('const int _num%s = %s;' % (k, v.size))
except TypeError:
pass
for line in lines:
# Sometimes an array is referred to by to different keys in our
# dictionary -- make sure to never add a line twice
if not line in code_object_defs[codeobj.name]:
code_object_defs[codeobj.name].append(line)
# Generate the code objects
for codeobj in self.code_objects.itervalues():
ns = codeobj.variables
# TODO: fix these freeze/CONSTANTS hacks somehow - they work but not elegant.
code = freeze(codeobj.code.cpp_file, ns)
code = code.replace('%CONSTANTS%', '\n'.join(code_object_defs[codeobj.name]))
code = '#include "objects.h"\n'+code
writer.write('code_objects/'+codeobj.name+'.cpp', code)
writer.write('code_objects/'+codeobj.name+'.h', codeobj.code.h_file)
# The code_objects are passed in the right order to run them because they were
# sorted by the Network object. To support multiple clocks we'll need to be
# smarter about that.
main_tmp = CPPStandaloneCodeObject.templater.main(None, None,
main_lines=main_lines,
code_objects=self.code_objects.values(),
report_func=self.report_func,
dt=float(defaultclock.dt),
additional_headers=main_includes,
)
writer.write('main.cpp', main_tmp)
# Generate the run functions
run_tmp = CPPStandaloneCodeObject.templater.run(None, None, run_funcs=runfuncs,
code_objects=self.code_objects.values(),
additional_headers=run_includes,
)
writer.write('run.*', run_tmp)
# Copy the brianlibdirectory
brianlib_dir = os.path.join(os.path.split(inspect.getsourcefile(CPPStandaloneCodeObject))[0],
'brianlib')
brianlib_files = copy_directory(brianlib_dir, os.path.join(project_dir, 'brianlib'))
for file in brianlib_files:
if file.lower().endswith('.cpp'):
writer.source_files.append('brianlib/'+file)
elif file.lower().endswith('.h'):
writer.header_files.append('brianlib/'+file)
# Copy the CSpikeQueue implementation
spikequeue_h = os.path.join(project_dir, 'brianlib', 'spikequeue.h')
shutil.copy2(os.path.join(os.path.split(inspect.getsourcefile(Synapses))[0], 'cspikequeue.cpp'),
spikequeue_h)
#writer.header_files.append(spikequeue_h)
writer.source_files.extend(additional_source_files)
writer.header_files.extend(additional_header_files)
# Generate the makefile
if os.name=='nt':
rm_cmd = 'del'
else:
rm_cmd = 'rm'
makefile_tmp = CPPStandaloneCodeObject.templater.makefile(None, None,
source_files=' '.join(writer.source_files),
header_files=' '.join(writer.header_files),
rm_cmd=rm_cmd)
writer.write('makefile', makefile_tmp)
# build the project
if compile_project:
with in_directory(project_dir):
if debug:
x = os.system('make debug')
elif native:
x = os.system('make native')
else:
x = os.system('make')
if x==0:
if run_project:
if not with_output:
stdout = open(os.devnull, 'w')
else:
stdout = None
if os.name=='nt':
x = subprocess.call(['main'] + run_args, stdout=stdout)
else:
x = subprocess.call(['./main'] + run_args, stdout=stdout)
if x:
raise RuntimeError("Project run failed")
self.has_been_run = True
else:
raise RuntimeError("Project compilation failed")
logger = get_logger(__name__)
# default_buildopts stores default build options for Gcc compiler
default_buildopts = []
# Try to get architecture information to get the best compiler setting for
# Windows
msvc_arch_flag = ''
if platform.system() == 'Windows':
flags = None
previously_stored_flags = None
# Check whether we've already stored the CPU flags previously
user_dir = os.path.join(os.path.expanduser('~'), '.brian')
ensure_directory(user_dir)
flag_file = os.path.join(user_dir, 'cpu_flags.txt')
hostname = socket.gethostname()
if os.path.isfile(flag_file):
try:
with open(flag_file, 'r', encoding='utf-8') as f:
previously_stored_flags = json.load(f)
if hostname not in previously_stored_flags:
logger.debug('Ignoring stored CPU flags for a different host')
else:
flags = previously_stored_flags[hostname]
except (IOError, OSError) as ex:
logger.debug(
f'Opening file "{flag_file}" to get CPU flags failed with error "{str(ex)}".'
)
def build(self, project_dir='output', compile_project=True, run_project=False, debug=True,
with_output=True):
ensure_directory(project_dir)
for d in ['code_objects', 'results', 'static_arrays']:
ensure_directory(os.path.join(project_dir, d))
logger.debug("Writing C++ standalone project to directory "+os.path.normpath(project_dir))
# # Find numpy arrays in the namespaces and convert them into static
# # arrays. Hopefully they are correctly used in the code: For example,
# # this works for the namespaces for functions with C++ (e.g. TimedArray
# # treats it as a C array) but does not work in places that are
# # implicitly vectorized (state updaters, resets, etc.). But arrays
# # shouldn't be used there anyway.
for code_object in self.code_objects.itervalues():
for name, value in code_object.variables.iteritems():
if isinstance(value, numpy.ndarray):
self.static_arrays[name] = value
# write the static arrays
logger.debug("static arrays: "+str(sorted(self.static_arrays.keys())))
static_array_specs = []
for name, arr in self.static_arrays.iteritems():
arr.tofile(os.path.join(project_dir, 'static_arrays', name))
static_array_specs.append((name, c_data_type(arr.dtype), arr.size, name))
# Write the global objects
networks = [net() for net in Network.__instances__() if net().name!='_fake_network']
synapses = [S() for S in Synapses.__instances__()]
arr_tmp = CPPStandaloneCodeObject.templater.objects(None,
array_specs=self.arrays,
dynamic_array_specs=self.dynamic_arrays,
dynamic_array_2d_specs=self.dynamic_arrays_2d,
zero_arrays=self.zero_arrays,
arange_arrays=self.arange_arrays,
synapses=synapses,
clocks=self.clocks,
static_array_specs=static_array_specs,
networks=networks,
)
logger.debug("objects: "+str(arr_tmp))
open(os.path.join(project_dir, 'objects.cpp'), 'w').write(arr_tmp.cpp_file)
open(os.path.join(project_dir, 'objects.h'), 'w').write(arr_tmp.h_file)
main_lines = []
for func, args in self.main_queue:
if func=='run_code_object':
codeobj, = args
main_lines.append('_run_%s(t);' % codeobj.name)
elif func=='run_network':
net, netcode = args
main_lines.extend(netcode)
elif func=='set_by_array':
arrayname, staticarrayname = args
code = '''
for(int i=0; i<_num_{staticarrayname}; i++)
{{
{arrayname}[i] = {staticarrayname}[i];
}}
'''.format(arrayname=arrayname, staticarrayname=staticarrayname)
main_lines.extend(code.split('\n'))
elif func=='set_array_by_array':
arrayname, staticarrayname_index, staticarrayname_value = args
code = '''
for(int i=0; i<_num_{staticarrayname_index}; i++)
{{
{arrayname}[{staticarrayname_index}[i]] = {staticarrayname_value}[i];
}}
'''.format(arrayname=arrayname, staticarrayname_index=staticarrayname_index,
staticarrayname_value=staticarrayname_value)
main_lines.extend(code.split('\n'))
elif func=='insert_code':
main_lines.append(args)
else:
raise NotImplementedError("Unknown main queue function type "+func)
# generate the finalisations
for codeobj in self.code_objects.itervalues():
if hasattr(codeobj.code, 'main_finalise'):
main_lines.append(codeobj.code.main_finalise)
# Generate data for non-constant values
handled_arrays = defaultdict(set)
code_object_defs = defaultdict(list)
for codeobj in self.code_objects.itervalues():
for k, v in codeobj.variables.iteritems():
if k=='t':
pass
elif isinstance(v, Subexpression):
pass
elif isinstance(v, AttributeVariable):
c_type = c_data_type(v.dtype)
# TODO: Handle dt in the correct way
if v.attribute == 'dt_':
code = ('const {c_type} {k} = '
'{value};').format(c_type=c_type,
k=k,
value=v.get_value())
else:
code = ('const {c_type} {k} = '
'{name}.{attribute};').format(c_type=c_type,
k=k,
name=v.obj.name,
attribute=v.attribute)
code_object_defs[codeobj.name].append(code)
elif isinstance(v, ArrayVariable):
try:
if isinstance(v, DynamicArrayVariable):
if v.dimensions == 1:
dyn_array_name = self.dynamic_arrays[v]
array_name = self.arrays[v]
code_object_defs[codeobj.name].append('{c_type}* const {array_name} = &{dyn_array_name}[0];'.format(c_type=c_data_type(v.dtype),
array_name=array_name,
dyn_array_name=dyn_array_name))
code_object_defs[codeobj.name].append('const int _num{k} = {dyn_array_name}.size();'.format(k=k,
dyn_array_name=dyn_array_name))
else:
code_object_defs[codeobj.name].append('const int _num%s = %s;' % (k, v.size))
except TypeError:
pass
# Generate the code objects
for codeobj in self.code_objects.itervalues():
ns = codeobj.variables
# TODO: fix these freeze/CONSTANTS hacks somehow - they work but not elegant.
code = freeze(codeobj.code.cpp_file, ns)
code = code.replace('%CONSTANTS%', '\n'.join(code_object_defs[codeobj.name]))
code = '#include "objects.h"\n'+code
open(os.path.join(project_dir, 'code_objects', codeobj.name+'.cpp'), 'w').write(code)
open(os.path.join(project_dir, 'code_objects', codeobj.name+'.h'), 'w').write(codeobj.code.h_file)
# The code_objects are passed in the right order to run them because they were
# sorted by the Network object. To support multiple clocks we'll need to be
# smarter about that.
main_tmp = CPPStandaloneCodeObject.templater.main(None,
main_lines=main_lines,
code_objects=self.code_objects.values(),
dt=float(defaultclock.dt),
)
logger.debug("main: "+str(main_tmp))
open(os.path.join(project_dir, 'main.cpp'), 'w').write(main_tmp)
# Copy the brianlibdirectory
brianlib_dir = os.path.join(os.path.split(inspect.getsourcefile(CPPStandaloneCodeObject))[0],
'brianlib')
copy_directory(brianlib_dir, os.path.join(project_dir, 'brianlib'))
# Copy the CSpikeQueue implementation
shutil.copy(os.path.join(os.path.split(inspect.getsourcefile(Synapses))[0],
'cspikequeue.cpp'),
os.path.join(project_dir, 'brianlib', 'spikequeue.h'))
# build the project
if compile_project:
with in_directory(project_dir):
if debug:
x = os.system('g++ -I. -g *.cpp code_objects/*.cpp brianlib/*.cpp -o main')
else:
x = os.system('g++ -I. -O3 -ffast-math -march=native *.cpp code_objects/*.cpp brianlib/*.cpp -o main')
if x==0:
if run_project:
if not with_output:
stdout = open(os.devnull, 'w')
else:
stdout = None
if os.name=='nt':
x = subprocess.call('main', stdout=stdout)
else:
x = subprocess.call('./main', stdout=stdout)
if x:
raise RuntimeError("Project run failed")
else:
raise RuntimeError("Project compilation failed")
def build(self, directory='output',
compile=True, run=True, debug=False, clean=True,
with_output=True, native=True,
additional_source_files=None, additional_header_files=None,
main_includes=None, run_includes=None,
run_args=None, **kwds):
'''
Build the project
TODO: more details
Parameters
----------
directory : str
The output directory to write the project to, any existing files will be overwritten.
compile : bool
Whether or not to attempt to compile the project
run : bool
Whether or not to attempt to run the built project if it successfully builds.
debug : bool
Whether to compile in debug mode.
with_output : bool
Whether or not to show the ``stdout`` of the built program when run.
native : bool
Whether or not to compile for the current machine's architecture (best for speed, but not portable)
clean : bool
Whether or not to clean the project before building
additional_source_files : list of str
A list of additional ``.cpp`` files to include in the build.
additional_header_files : list of str
A list of additional ``.h`` files to include in the build.
main_includes : list of str
A list of additional header files to include in ``main.cpp``.
run_includes : list of str
A list of additional header files to include in ``run.cpp``.
'''
renames = {'project_dir': 'directory',
'compile_project': 'compile',
'run_project': 'run'}
if len(kwds):
msg = ''
for kwd in kwds:
if kwd in renames:
msg += ("Keyword argument '%s' has been renamed to "
"'%s'. ") % (kwd, renames[kwd])
else:
msg += "Unknown keyword argument '%s'. " % kwd
raise TypeError(msg)
if additional_source_files is None:
additional_source_files = []
if additional_header_files is None:
additional_header_files = []
if main_includes is None:
main_includes = []
if run_includes is None:
run_includes = []
if run_args is None:
run_args = []
self.project_dir = directory
ensure_directory(directory)
compiler, extra_compile_args = get_compiler_and_args()
compiler_flags = ' '.join(extra_compile_args)
for d in ['code_objects', 'results', 'static_arrays']:
ensure_directory(os.path.join(directory, d))
writer = CPPWriter(directory)
# Get the number of threads if specified in an openmp context
nb_threads = prefs.devices.cpp_standalone.openmp_threads
# If the number is negative, we need to throw an error
if (nb_threads < 0):
raise ValueError('The number of OpenMP threads can not be negative !')
logger.debug("Writing C++ standalone project to directory "+os.path.normpath(directory))
if nb_threads > 0:
logger.warn("OpenMP code is not yet well tested, and may be inaccurate.", "openmp", once=True)
logger.debug("Using OpenMP with %d threads " % nb_threads)
for codeobj in self.code_objects.itervalues():
if not 'IS_OPENMP_COMPATIBLE' in codeobj.template_source:
raise RuntimeError(("Code object '%s' uses the template %s "
"which is not compatible with "
"OpenMP.") % (codeobj.name,
codeobj.template_name))
arange_arrays = sorted([(var, start)
for var, start in self.arange_arrays.iteritems()],
key=lambda (var, start): var.name)
# # Find np arrays in the namespaces and convert them into static
# # arrays. Hopefully they are correctly used in the code: For example,
# # this works for the namespaces for functions with C++ (e.g. TimedArray
# # treats it as a C array) but does not work in places that are
# # implicitly vectorized (state updaters, resets, etc.). But arrays
# # shouldn't be used there anyway.
for code_object in self.code_objects.itervalues():
for name, value in code_object.variables.iteritems():
if isinstance(value, np.ndarray):
self.static_arrays[name] = value
# write the static arrays
logger.debug("static arrays: "+str(sorted(self.static_arrays.keys())))
static_array_specs = []
for name, arr in sorted(self.static_arrays.items()):
arr.tofile(os.path.join(directory, 'static_arrays', name))
static_array_specs.append((name, c_data_type(arr.dtype), arr.size, name))
# Write the global objects
networks = [net() for net in Network.__instances__()
if net().name != '_fake_network']
synapses = []
for net in networks:
net_synapses = [s for s in net.objects if isinstance(s, Synapses)]
synapses.extend(net_synapses)
# We don't currently support pathways with scalar delays
for synapse_obj in net_synapses:
for pathway in synapse_obj._pathways:
if not isinstance(pathway.variables['delay'],
DynamicArrayVariable):
error_msg = ('The "%s" pathway uses a scalar '
'delay (instead of a delay per synapse). '
'This is not yet supported. Do not '
'specify a delay in the Synapses(...) '
'call but instead set its delay attribute '
'afterwards.') % (pathway.name)
raise NotImplementedError(error_msg)
# Not sure what the best place is to call Network.after_run -- at the
# moment the only important thing it does is to clear the objects stored
# in magic_network. If this is not done, this might lead to problems
# for repeated runs of standalone (e.g. in the test suite).
for net in networks:
net.after_run()
arr_tmp = CPPStandaloneCodeObject.templater.objects(
None, None,
array_specs=self.arrays,
dynamic_array_specs=self.dynamic_arrays,
dynamic_array_2d_specs=self.dynamic_arrays_2d,
zero_arrays=self.zero_arrays,
arange_arrays=arange_arrays,
synapses=synapses,
clocks=self.clocks,
static_array_specs=static_array_specs,
networks=networks)
writer.write('objects.*', arr_tmp)
main_lines = []
procedures = [('', main_lines)]
runfuncs = {}
for func, args in self.main_queue:
if func=='run_code_object':
codeobj, = args
main_lines.append('_run_%s();' % codeobj.name)
elif func=='run_network':
net, netcode = args
main_lines.extend(netcode)
elif func=='set_by_array':
arrayname, staticarrayname = args
code = '''
{pragma}
for(int i=0; i<_num_{staticarrayname}; i++)
{{
{arrayname}[i] = {staticarrayname}[i];
}}
'''.format(arrayname=arrayname, staticarrayname=staticarrayname, pragma=openmp_pragma('static'))
main_lines.extend(code.split('\n'))
elif func=='set_by_single_value':
arrayname, item, value = args
code = '{arrayname}[{item}] = {value};'.format(arrayname=arrayname,
item=item,
value=value)
main_lines.extend([code])
elif func=='set_array_by_array':
arrayname, staticarrayname_index, staticarrayname_value = args
code = '''
{pragma}
for(int i=0; i<_num_{staticarrayname_index}; i++)
{{
{arrayname}[{staticarrayname_index}[i]] = {staticarrayname_value}[i];
}}
'''.format(arrayname=arrayname, staticarrayname_index=staticarrayname_index,
staticarrayname_value=staticarrayname_value, pragma=openmp_pragma('static'))
main_lines.extend(code.split('\n'))
elif func=='insert_code':
main_lines.append(args)
elif func=='start_run_func':
name, include_in_parent = args
if include_in_parent:
main_lines.append('%s();' % name)
main_lines = []
procedures.append((name, main_lines))
elif func=='end_run_func':
name, include_in_parent = args
name, main_lines = procedures.pop(-1)
runfuncs[name] = main_lines
name, main_lines = procedures[-1]
else:
raise NotImplementedError("Unknown main queue function type "+func)
# generate the finalisations
for codeobj in self.code_objects.itervalues():
if hasattr(codeobj.code, 'main_finalise'):
main_lines.append(codeobj.code.main_finalise)
# Generate data for non-constant values
code_object_defs = defaultdict(list)
for codeobj in self.code_objects.itervalues():
lines = []
for k, v in codeobj.variables.iteritems():
if isinstance(v, AttributeVariable):
# We assume all attributes are implemented as property-like methods
line = 'const {c_type} {varname} = {objname}.{attrname}();'
lines.append(line.format(c_type=c_data_type(v.dtype), varname=k, objname=v.obj.name,
attrname=v.attribute))
elif isinstance(v, ArrayVariable):
try:
if isinstance(v, DynamicArrayVariable):
if v.dimensions == 1:
dyn_array_name = self.dynamic_arrays[v]
array_name = self.arrays[v]
line = '{c_type}* const {array_name} = &{dyn_array_name}[0];'
line = line.format(c_type=c_data_type(v.dtype), array_name=array_name,
dyn_array_name=dyn_array_name)
lines.append(line)
line = 'const int _num{k} = {dyn_array_name}.size();'
line = line.format(k=k, dyn_array_name=dyn_array_name)
lines.append(line)
else:
lines.append('const int _num%s = %s;' % (k, v.size))
except TypeError:
pass
for line in lines:
# Sometimes an array is referred to by to different keys in our
# dictionary -- make sure to never add a line twice
if not line in code_object_defs[codeobj.name]:
code_object_defs[codeobj.name].append(line)
# Generate the code objects
for codeobj in self.code_objects.itervalues():
ns = codeobj.variables
# TODO: fix these freeze/CONSTANTS hacks somehow - they work but not elegant.
code = freeze(codeobj.code.cpp_file, ns)
code = code.replace('%CONSTANTS%', '\n'.join(code_object_defs[codeobj.name]))
code = '#include "objects.h"\n'+code
writer.write('code_objects/'+codeobj.name+'.cpp', code)
writer.write('code_objects/'+codeobj.name+'.h', codeobj.code.h_file)
# The code_objects are passed in the right order to run them because they were
# sorted by the Network object. To support multiple clocks we'll need to be
# smarter about that.
main_tmp = CPPStandaloneCodeObject.templater.main(None, None,
main_lines=main_lines,
code_objects=self.code_objects.values(),
report_func=self.report_func,
dt=float(defaultclock.dt),
additional_headers=main_includes,
)
writer.write('main.cpp', main_tmp)
if compiler=='msvc':
std_move = 'std::move'
else:
std_move = ''
network_tmp = CPPStandaloneCodeObject.templater.network(None, None,
std_move=std_move)
writer.write('network.*', network_tmp)
synapses_classes_tmp = CPPStandaloneCodeObject.templater.synapses_classes(None, None)
writer.write('synapses_classes.*', synapses_classes_tmp)
# Generate the run functions
run_tmp = CPPStandaloneCodeObject.templater.run(None, None, run_funcs=runfuncs,
code_objects=self.code_objects.values(),
additional_headers=run_includes,
)
writer.write('run.*', run_tmp)
# Copy the brianlibdirectory
brianlib_dir = os.path.join(os.path.split(inspect.getsourcefile(CPPStandaloneCodeObject))[0],
'brianlib')
brianlib_files = copy_directory(brianlib_dir, os.path.join(directory, 'brianlib'))
for file in brianlib_files:
if file.lower().endswith('.cpp'):
writer.source_files.append('brianlib/'+file)
elif file.lower().endswith('.h'):
writer.header_files.append('brianlib/'+file)
# Copy the CSpikeQueue implementation
shutil.copy2(os.path.join(os.path.split(inspect.getsourcefile(Synapses))[0], 'cspikequeue.cpp'),
os.path.join(directory, 'brianlib', 'spikequeue.h'))
shutil.copy2(os.path.join(os.path.split(inspect.getsourcefile(Synapses))[0], 'stdint_compat.h'),
os.path.join(directory, 'brianlib', 'stdint_compat.h'))
writer.source_files.extend(additional_source_files)
writer.header_files.extend(additional_header_files)
if compiler=='msvc':
if native:
arch_flag = ''
try:
from cpuinfo import cpuinfo
res = cpuinfo.get_cpu_info()
if 'sse' in res['flags']:
arch_flag = '/arch:SSE'
if 'sse2' in res['flags']:
arch_flag = '/arch:SSE2'
except ImportError:
logger.warn('Native flag for MSVC compiler requires installation of the py-cpuinfo module')
compiler_flags += ' '+arch_flag
if nb_threads>1:
openmp_flag = '/openmp'
else:
openmp_flag = ''
# Generate the visual studio makefile
source_bases = [fname.replace('.cpp', '').replace('/', '\\') for fname in writer.source_files]
win_makefile_tmp = CPPStandaloneCodeObject.templater.win_makefile(
None, None,
source_bases=source_bases,
compiler_flags=compiler_flags,
openmp_flag=openmp_flag,
)
writer.write('win_makefile', win_makefile_tmp)
else:
# Generate the makefile
if os.name=='nt':
rm_cmd = 'del *.o /s\n\tdel main.exe $(DEPS)'
else:
rm_cmd = 'rm $(OBJS) $(PROGRAM) $(DEPS)'
makefile_tmp = CPPStandaloneCodeObject.templater.makefile(None, None,
source_files=' '.join(writer.source_files),
header_files=' '.join(writer.header_files),
compiler_flags=compiler_flags,
rm_cmd=rm_cmd)
writer.write('makefile', makefile_tmp)
# build the project
if compile:
with in_directory(directory):
if compiler=='msvc':
# TODO: handle debug
if debug:
logger.warn('Debug flag currently ignored for MSVC')
vcvars_search_paths = [
# futureproofing!
r'c:\Program Files\Microsoft Visual Studio 15.0\VC\vcvarsall.bat',
r'c:\Program Files (x86)\Microsoft Visual Studio 15.0\VC\vcvarsall.bat',
r'c:\Program Files\Microsoft Visual Studio 14.0\VC\vcvarsall.bat',
r'c:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat',
r'c:\Program Files\Microsoft Visual Studio 13.0\VC\vcvarsall.bat',
r'c:\Program Files (x86)\Microsoft Visual Studio 13.0\VC\vcvarsall.bat',
r'c:\Program Files\Microsoft Visual Studio 12.0\VC\vcvarsall.bat',
r'c:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\vcvarsall.bat',
r'c:\Program Files\Microsoft Visual Studio 11.0\VC\vcvarsall.bat',
r'c:\Program Files (x86)\Microsoft Visual Studio 11.0\VC\vcvarsall.bat',
r'c:\Program Files\Microsoft Visual Studio 10.0\VC\vcvarsall.bat',
r'c:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\vcvarsall.bat',
]
vcvars_loc = prefs['codegen.cpp.msvc_vars_location']
if vcvars_loc=='':
for fname in vcvars_search_paths:
if os.path.exists(fname):
vcvars_loc = fname
break
if vcvars_loc=='':
raise IOError("Cannot find vcvarsall.bat on standard search path.")
# TODO: copy vcvars and make replacements for 64 bit automatically
arch_name = prefs['codegen.cpp.msvc_architecture']
if arch_name=='':
mach = platform.machine()
if mach=='AMD64':
arch_name = 'x86_amd64'
else:
arch_name = 'x86'
vcvars_cmd = '"{vcvars_loc}" {arch_name}'.format(
vcvars_loc=vcvars_loc, arch_name=arch_name)
make_cmd = 'nmake /f win_makefile'
if os.path.exists('winmake.log'):
os.remove('winmake.log')
with std_silent(debug):
if clean:
os.system('%s >>winmake.log 2>&1 && %s clean >>winmake.log 2>&1' % (vcvars_cmd, make_cmd))
x = os.system('%s >>winmake.log 2>&1 && %s >>winmake.log 2>&1' % (vcvars_cmd, make_cmd))
if x!=0:
raise RuntimeError("Project compilation failed")
else:
with std_silent(debug):
if clean:
os.system('make clean')
if debug:
x = os.system('make debug')
elif native:
x = os.system('make native')
else:
x = os.system('make')
if x!=0:
raise RuntimeError("Project compilation failed")
if run:
if not with_output:
stdout = open(os.devnull, 'w')
else:
stdout = None
if os.name=='nt':
x = subprocess.call(['main'] + run_args, stdout=stdout)
else:
x = subprocess.call(['./main'] + run_args, stdout=stdout)
if x:
raise RuntimeError("Project run failed")
self.has_been_run = True
