| # Copyright (c) 2016, 2017 ARM Limited. |
| # |
| # SPDX-License-Identifier: MIT |
| # |
| # Permission is hereby granted, free of charge, to any person obtaining a copy |
| # of this software and associated documentation files (the "Software"), to |
| # deal in the Software without restriction, including without limitation the |
| # rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
| # sell copies of the Software, and to permit persons to whom the Software is |
| # furnished to do so, subject to the following conditions: |
| # |
| # The above copyright notice and this permission notice shall be included in all |
| # copies or substantial portions of the Software. |
| # |
| # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
| # SOFTWARE. |
| import collections |
| import os.path |
| import re |
| import subprocess |
| import SCons |
| |
| VERSION = "v17.05" |
| SONAME_VERSION="2.0.0" |
| |
| Import('env') |
| Import('vars') |
| |
| def version_at_least(version, required): |
| end = min(len(version), len(required)) |
| |
| for i in range(0, end, 2): |
| if int(version[i]) < int(required[i]): |
| return False |
| elif int(version[i]) > int(required[i]): |
| return True |
| |
| return True |
| |
| def build_library(name, sources, libs, static=False): |
| if static: |
| obj = env.StaticLibrary(name, source = sources, LIBS=libs ) |
| else: |
| if env['set_soname']: |
| obj = env.SharedLibrary(name, source = sources, LIBS=libs, SHLIBVERSION=SONAME_VERSION) |
| symlinks = [] |
| # Manually delete symlinks or SCons will get confused: |
| directory = os.path.dirname( obj[0].path ) |
| library_prefix = obj[0].path[:-(1+len(SONAME_VERSION))] |
| real_lib="%s.%s" % (library_prefix, SONAME_VERSION) |
| for f in Glob( "#%s*" % library_prefix): |
| if str(f) != real_lib: |
| symlinks.append("%s/%s" % (directory,str(f))) |
| clean = env.Command('clean-%s' % str(obj[0]), [], Delete(symlinks)) |
| Default(clean) |
| Depends(obj, clean) |
| else: |
| obj = env.SharedLibrary(name, source = sources, LIBS=libs) |
| |
| Default(obj) |
| return obj |
| |
| def resolve_includes(target, source, env): |
| # File collection |
| FileEntry = collections.namedtuple('FileEntry', 'target_name file_contents') |
| |
| # Include pattern |
| pattern = re.compile("#include \"(.*)\"") |
| |
| # Get file contents |
| files = [] |
| for s in source: |
| name = s.rstr().split("/")[-1] |
| contents = s.get_contents().splitlines() |
| embed_target_name = s.abspath + "embed" |
| entry = FileEntry(target_name=embed_target_name, file_contents=contents) |
| files.append((name,entry)) |
| |
| # Create dictionary of tupled list |
| files_dict = dict(files) |
| |
| # Check for includes (can only be files in the same folder) |
| final_files = [] |
| for file in files: |
| done = False |
| tmp_file = file[1].file_contents |
| while not done: |
| file_count = 0 |
| updated_file = [] |
| for line in tmp_file: |
| found = pattern.search(line) |
| if found: |
| include_file = found.group(1) |
| data = files_dict[include_file].file_contents |
| updated_file.extend(data) |
| else: |
| updated_file.append(line) |
| file_count += 1 |
| |
| # Check if all include are replaced. |
| if file_count == len(tmp_file): |
| done = True |
| |
| # Update temp file |
| tmp_file = updated_file |
| |
| # Append and prepend string literal identifiers and add expanded file to final list |
| tmp_file.insert(0, "R\"(\n") |
| tmp_file.append("\n)\"") |
| entry = FileEntry(target_name=file[1].target_name, file_contents=tmp_file) |
| final_files.append((file[0], entry)) |
| |
| # Write output files |
| for file in final_files: |
| with open(file[1].target_name, 'w+') as out_file: |
| contents = file[1].file_contents |
| for line in contents: |
| out_file.write("%s\n" % line) |
| |
| if GetOption("help"): |
| Exit(0) |
| |
| flags = ['-D_GLIBCXX_USE_NANOSLEEP','-Wno-deprecated-declarations','-Wall','-DARCH_ARM', |
| '-Wextra','-Wno-unused-parameter','-pedantic','-Wdisabled-optimization','-Wformat=2', |
| '-Winit-self','-Wstrict-overflow=2','-Wswitch-default', |
| '-fpermissive','-std=gnu++11','-Wno-vla','-Woverloaded-virtual', |
| '-Wctor-dtor-privacy','-Wsign-promo','-Weffc++','-Wno-format-nonliteral','-Wno-overlength-strings','-Wno-strict-overflow'] |
| |
| if env['neon'] and 'x86' in env['arch']: |
| print "Cannot compile NEON for x86" |
| Exit(1) |
| |
| if env['set_soname'] and not version_at_least(SCons.__version__, "2.4"): |
| print "Setting the library's SONAME / SHLIBVERSION requires SCons 2.4 or above" |
| print "Update your version of SCons or use set_soname=0" |
| Exit(1) |
| |
| if os.environ.get('CXX','g++') == 'clang++': |
| flags += ['-Wno-format-nonliteral','-Wno-deprecated-increment-bool','-Wno-vla-extension','-Wno-mismatched-tags'] |
| else: |
| flags += ['-Wlogical-op','-Wnoexcept','-Wstrict-null-sentinel'] |
| |
| if env['cppthreads']: |
| flags += ['-DARM_COMPUTE_CPP_SCHEDULER=1'] |
| |
| if env['openmp']: |
| if os.environ.get('CXX','g++') == 'clang++': |
| print "Clang does not support OpenMP. Use scheduler=cpp." |
| Exit(1) |
| |
| flags += ['-DARM_COMPUTE_OPENMP_SCHEDULER=1','-fopenmp'] |
| env.Append(LINKFLAGS=['-fopenmp']) |
| |
| files_to_delete = [] |
| |
| # Generate string with build options library version to embed in the library: |
| try: |
| git_hash = subprocess.check_output(["git", "rev-parse","HEAD"]) |
| except (OSError, subbprocess.CalledProcessError): |
| git_hash="unknown" |
| |
| version_filename = "%s/arm_compute_version.embed" % os.path.dirname(Glob("src/core/*")[0].rstr()) |
| build_info = "\"arm_compute_version=%s Build options: %s Git hash=%s\"" % (VERSION, vars.args, git_hash.strip()) |
| |
| with open(version_filename, "w") as fd: |
| fd.write(build_info) |
| |
| files_to_delete.append(version_filename) |
| |
| core_libs = ['dl'] |
| libs = ['dl'] |
| |
| prefix="" |
| |
| if env['arch'] == 'armv7a': |
| flags += ['-march=armv7-a','-mthumb','-mfpu=neon'] |
| |
| if env['os'] in ['linux','bare_metal']: |
| prefix = "arm-linux-gnueabihf-" |
| flags += ['-mfloat-abi=hard'] |
| elif env['os'] == 'android': |
| prefix = "arm-linux-androideabi-" |
| flags += ['-mfloat-abi=softfp'] |
| elif env['arch'] == 'arm64-v8a': |
| flags += ['-march=armv8-a'] |
| |
| if env['os'] in ['linux','bare_metal']: |
| prefix = "aarch64-linux-gnu-" |
| elif env['os'] == 'android': |
| prefix = "aarch64-linux-android-" |
| elif env['arch'] == 'arm64-v8.2-a': |
| flags += ['-march=armv8.2-a+fp16+simd'] |
| flags += ['-DARM_COMPUTE_ENABLE_FP16'] |
| |
| if env['os'] in ['linux','bare_metal']: |
| prefix = "aarch64-linux-gnu-" |
| elif env['os'] == 'android': |
| prefix = "aarch64-linux-android-" |
| elif env['arch'] == 'x86_32': |
| flags += ['-m32'] |
| elif env['arch'] == 'x86_64': |
| flags += ['-m64'] |
| |
| if env['build'] == 'native': |
| prefix = "" |
| |
| env['CC'] = prefix + os.environ.get('CC','gcc') |
| env['CXX'] = prefix + os.environ.get('CXX','g++') |
| env['LD'] = prefix + "ld" |
| env['AS'] = prefix + "as" |
| env['AR'] = prefix + "ar" |
| env['RANLIB'] = prefix + "ranlib" |
| |
| try: |
| compiler_ver = subprocess.check_output( [env['CXX'] , "-dumpversion"] ).strip() |
| except OSError: |
| print "ERROR: Compiler '%s' not found" % env['CXX'] |
| Exit(1) |
| |
| if os.environ.get('CXX','g++') == 'g++': |
| if env['arch'] == 'arm64-v8.2-a' and not version_at_least(compiler_ver, '6.2.1'): |
| print "GCC 6.2.1 or newer is required to compile armv8.2-a code" |
| Exit(1) |
| |
| if env['arch'] == 'arm64-v8a' and not version_at_least(compiler_ver, '4.9'): |
| print "GCC 4.9 or newer is required to compile NEON code for AArch64" |
| Exit(1) |
| |
| if version_at_least(compiler_ver, '6.1'): |
| flags += ['-Wno-ignored-attributes'] |
| |
| if compiler_ver == '4.8.3': |
| flags += ['-Wno-array-bounds'] |
| |
| if env['Werror']: |
| flags += ['-Werror'] |
| |
| example_libs = [] |
| |
| if env['os'] == 'android': |
| flags += ['-DANDROID'] |
| env.Append(LINKFLAGS=['-pie','-static-libstdc++']) |
| example_libs = ['arm_compute-static'] |
| elif env['os'] == 'bare_metal': |
| env.Append(LINKFLAGS=['-static']) |
| flags += ['-fPIC','-DNO_MULTI_THREADING'] |
| example_libs = ['arm_compute-static'] |
| else: |
| libs += ['pthread'] |
| example_libs = ['arm_compute'] |
| |
| if env['opencl']: |
| if env['os'] == 'bare_metal': |
| raise Exception("Cannot link OpenCL statically, which is required on bare metal") |
| if env['embed_kernels']: |
| flags += ['-DEMBEDDED_KERNELS'] |
| |
| if env['debug']: |
| env['asserts'] = True |
| flags += ['-O0','-g','-gdwarf-2'] |
| else: |
| flags += ['-O3','-ftree-vectorize'] |
| |
| if env['asserts']: |
| flags += ['-DARM_COMPUTE_ASSERTS_ENABLED'] |
| |
| env.Append(CPPPATH=['.','#include']) |
| env.Append(LIBPATH=['#build/%s' % env['build_dir'],'.']) |
| env.Append(CXXFLAGS=flags) |
| env.Append(CXXFLAGS=env['extra_cxx_flags']) |
| |
| core_files = Glob('src/core/*.cpp') |
| core_files += Glob('src/core/CPP/*.cpp') |
| |
| files = Glob('src/runtime/*.cpp') |
| |
| embed_files = [] |
| core_files += Glob('src/core/CPP/kernels/*.cpp') |
| # CLHarrisCorners uses the Scheduler to run CPP kernels |
| files += Glob('src/runtime/CPP/SingleThreadScheduler.cpp') |
| |
| if env['os'] == 'bare_metal': |
| if env['cppthreads'] or env['openmp']: |
| print "ERROR: OpenMP and C++11 threads not supported in bare_metal. Use cppthreads=0 openmp=0" |
| Exit(1) |
| else: |
| if env['cppthreads']: |
| files += Glob('src/runtime/CPP/CPPScheduler.cpp') |
| if env['openmp']: |
| files += Glob('src/runtime/OMP/OMPScheduler.cpp') |
| |
| if env['opencl']: |
| core_files += Glob('src/core/CL/*.cpp') |
| core_files += Glob('src/core/CL/kernels/*.cpp') |
| files += Glob('src/runtime/CL/*.cpp') |
| files += Glob('src/runtime/CL/functions/*.cpp') |
| |
| # Generate embed files |
| if env['embed_kernels']: |
| cl_files = Glob('src/core/CL/cl_kernels/*.cl') + Glob('src/core/CL/cl_kernels/*.h') |
| source_list = [] |
| for file in cl_files: |
| source_name = file.rstr() |
| source_list.append(source_name) |
| embed_files.append(source_name + "embed") |
| generate_embed = env.Command(embed_files, source_list, action=resolve_includes) |
| Default(generate_embed) |
| files_to_delete += embed_files |
| |
| if env['neon']: |
| core_files += Glob('src/core/NEON/*.cpp') |
| core_files += Glob('src/core/NEON/kernels/*.cpp') |
| files += Glob('src/runtime/NEON/*.cpp') |
| files += Glob('src/runtime/NEON/functions/*.cpp') |
| |
| objects=[] |
| static_core_objects = [ env.StaticObject( f ) for f in core_files ] |
| shared_core_objects = [ env.SharedObject( f ) for f in core_files ] |
| |
| arm_compute_core_a = build_library('arm_compute_core-static', static_core_objects, core_libs, static=True) |
| objects.append(arm_compute_core_a) |
| Export('arm_compute_core_a') |
| |
| if env['os'] != 'bare_metal': |
| arm_compute_core_so = build_library('arm_compute_core', shared_core_objects, core_libs, static=False) |
| objects.append(arm_compute_core_so) |
| Export('arm_compute_core_so') |
| |
| shared_objects = [ env.SharedObject( f ) for f in files ] |
| static_objects = [ env.StaticObject( f ) for f in files ] |
| |
| arm_compute_a = build_library('arm_compute-static', static_core_objects + static_objects, libs, static=True) |
| objects.append(arm_compute_a) |
| Export('arm_compute_a') |
| |
| if env['os'] != 'bare_metal': |
| arm_compute_so = build_library('arm_compute', shared_core_objects + shared_objects, libs, static=False) |
| objects.append(arm_compute_so) |
| Export('arm_compute_so') |
| |
| # Delete produced embed files |
| clean_embed = env.Command('clean-embed', [], Delete(files_to_delete)) |
| Default(clean_embed) |
| env.Depends(clean_embed, objects) |
| alias = env.Alias("arm_compute",objects) |
| Default(alias) |
| |
| # Build examples |
| |
| if env['examples']: |
| test_helpers = env.Object("test_helpers/Utils.cpp") |
| |
| if env['opencl'] and env['neon']: |
| for file in Glob("examples/neoncl_*.cpp"): |
| example = os.path.basename( os.path.splitext(str(file))[0]) |
| prog = env.Program(example, ['examples/%s.cpp' % example, test_helpers], LIBS=example_libs+['OpenCL']) |
| alias = env.Alias(example, prog) |
| Depends(prog, objects) |
| Default( alias ) |
| |
| if env['opencl']: |
| for file in Glob("examples/cl_*.cpp"): |
| example = os.path.basename( os.path.splitext(str(file))[0]) |
| prog = env.Program(example, ['examples/%s.cpp' % example, test_helpers], LIBS=example_libs+['OpenCL']) |
| alias = env.Alias(example, prog) |
| Depends(prog, objects) |
| Default( alias ) |
| |
| if env['neon']: |
| for file in Glob("examples/neon_*.cpp"): |
| example = os.path.basename( os.path.splitext(str(file))[0]) |
| prog = env.Program(example, ['examples/%s.cpp' % example, test_helpers], LIBS=example_libs) |
| alias = env.Alias(example, prog) |
| Depends(prog, objects) |
| Default( alias ) |
| |
| Export('env') |