Exemple #1
0
 def compile( self, source_dir, build_dir, install_dir ):
     package_source_dir = os.path.join( source_dir, self.dirname )
     assert( os.path.exists( package_source_dir ) )
     package_build_dir = os.path.join( build_dir, self.dirname )
     runpath_dir = os.path.join( package_source_dir, 'RunPath' )
     if ( not os.path.exists( os.path.join( runpath_dir, 'media.zip' ) ) ):
         sh.cd( runpath_dir )
         sh.wget( '--no-check-certificate', 'https://bitbucket.org/jacmoe/ogitor/downloads/media.zip' )
         sh.unzip( 'media.zip' )
     if ( not os.path.exists( os.path.join( runpath_dir, 'projects.zip' ) ) ):
         sh.cd( runpath_dir )
         sh.wget( '--no-check-certificate', 'https://bitbucket.org/jacmoe/ogitor/downloads/projects.zip' )
         sh.unzip( 'projects.zip' )
     sh.mkdir( '-p', package_build_dir )
     sh.cd( package_build_dir )
     if ( platform.system() == 'Darwin' ):
         sh.cmake(
             '-G', 'Xcode',
             '-D', 'CMAKE_INSTALL_PREFIX=%s' % install_dir,
             '-D', 'CMAKE_MODULE_PATH=%s' % os.path.join( install_dir, 'CMake' ),
             package_source_dir,
             _out = sys.stdout )
         sh.xcodebuild( '-configuration', 'Release', _out = sys.stdout )
     else:
         sh.cmake(
             '-D', 'CMAKE_INSTALL_PREFIX=%s' % install_dir,
             '-D', 'CMAKE_MODULE_PATH=%s' % os.path.join( install_dir, 'lib/OGRE/cmake' ),
             package_source_dir,
             _out = sys.stdout )
         sh.make( '-j4', 'VERBOSE=1', _out = sys.stdout )
         sh.make.install( _out = sys.stdout )
Exemple #2
0
 def compile(self, source_dir, build_dir, install_dir):
     package_source_dir = os.path.join(source_dir, self.dirname)
     assert (os.path.exists(package_source_dir))
     package_build_dir = os.path.join(build_dir, self.dirname)
     sh.mkdir('-p', package_build_dir)
     sh.cd(package_build_dir)
     if (platform.system() == 'Darwin'):
         sh.cmake('-G',
                  'Xcode',
                  '-D',
                  'CMAKE_INSTALL_PREFIX=%s' % install_dir,
                  package_source_dir,
                  _out=sys.stdout)
         sh.xcodebuild('-scheme',
                       'install',
                       '-configuration',
                       'Release',
                       _out=sys.stdout)
     else:
         sh.cmake('-D',
                  'CMAKE_INSTALL_PREFIX=%s' % install_dir,
                  package_source_dir,
                  _out=sys.stdout)
         sh.make('-j4', 'VERBOSE=1', _out=sys.stdout)
         sh.make.install(_out=sys.stdout)
def generate_template():
    template_file = ""
    if not isdir(build_dir):
        mkdir(build_dir)
    if isdir(build_dir):
        template_file = build_dir + "/dekko.dekkoproject.pot"
        print("TemplateFile: " + template_file)
        cd(build_dir)
        print("Running cmake to generate updated template")
        cmake('..')
        print("Running make")
        make("-j2")
    if isfile(template_file):
        if isdir(po_dir):
            print("Moving template to po dir: " + po_dir)
            mv(template_file, po_dir)
        else:
            print("Couldn't find po dir: " + po_dir)
            cleanup()
            return
    else:
        cleanup()
        print("No template found for: " + template_file)
        return
    print("Cleaning up")
    cleanup()
    print("YeeHaa!")
    print("All done, you need to commit & push this to bitbucket now :-)")
    print("NOTE: this would also be a good time to sync with launchpad, run")
    print("  $ python3 launchpad_sync.py")
Exemple #4
0
def BuildYcmdLibs(cmake_args):
    build_dir = unicode(sh.mktemp('-d', '-t', 'ycm_build.XXXXXX')).strip()

    try:
        full_cmake_args = ['-G', 'Unix Makefiles']
        if OnMac():
            full_cmake_args.extend(CustomPythonCmakeArgs())
        full_cmake_args.extend(cmake_args)
        full_cmake_args.append(p.join(DIR_OF_THIS_SCRIPT, 'cpp'))

        sh.cd(build_dir)
        sh.cmake(*full_cmake_args, _out=sys.stdout)

        build_target = ('ycm_support_libs' if 'YCM_TESTRUN' not in os.environ
                        else 'ycm_core_tests')
        sh.make('-j',
                NumCores(),
                build_target,
                _out=sys.stdout,
                _err=sys.stderr)

        if 'YCM_TESTRUN' in os.environ:
            RunYcmdTests(build_dir)
    finally:
        sh.cd(DIR_OF_THIS_SCRIPT)
        sh.rm('-rf', build_dir)
Exemple #5
0
def build_opencv():
    sh.pip.install("numpy")
    clone_if_not_exists("opencv", "https://github.com/PolarNick239/opencv.git", branch="stable_3.0.0)
    clone_if_not_exists("opencv_contrib", "https://github.com/PolarNick239/opencv_contrib.git", branch="stable_3.0.0")
    sh.rm("-rf", "build")
    sh.mkdir("build")
    sh.cd("build")
    python_path = pathlib.Path(sh.pyenv.which("python").stdout.decode()).parent.parent
    version = "{}.{}".format(sys.version_info.major, sys.version_info.minor)
    sh.cmake(
        "..",
        "-DCMAKE_BUILD_TYPE=RELEASE",
        "-DCMAKE_INSTALL_PREFIX={}/usr/local".format(python_path),
        "-DWITH_CUDA=OFF",
        "-DWITH_FFMPEG=OFF",
        "-DINSTALL_C_EXAMPLES=OFF",
        "-DBUILD_opencv_legacy=OFF",
        "-DBUILD_NEW_PYTHON_SUPPORT=ON",
        "-DBUILD_opencv_python3=ON",
        "-DOPENCV_EXTRA_MODULES_PATH=~/opencv_contrib-4.3.2/modules",
        "-DBUILD_EXAMPLES=ON",
        "-DPYTHON_EXECUTABLE={}/bin/python".format(python_path),
        "-DPYTHON3_LIBRARY={}/lib/libpython{}m.so".format(python_path, version),
        "-DPYTHON3_PACKAGES_PATH={}/lib/python{}/site-packages/".format(python_path, version),
        "-DPYTHON3_NUMPY_INCLUDE_DIRS={}/lib/python{}/site-packages/numpy/core/include".format(python_path, version),
        "-DPYTHON_INCLUDE_DIR={}/include/python{}m".format(python_path, version),
        _out=sys.stdout,
    )
    sh.make("-j4", _out=sys.stdout)
    sh.make.install(_out=sys.stdout)
Exemple #6
0
    def compile( self, source_dir, build_dir, install_dir ):
        package_source_dir = os.path.join( source_dir, self.dirname )
        assert( os.path.exists( package_source_dir ) )
        package_build_dir = os.path.join( build_dir, self.dirname )

        sh.cd( os.path.join( package_source_dir, 'scripts/Resources' ) )
        sh.sh( './copyresources.sh' )
        # the install target doesn't copy the stuff that copyresources.sh puts in place
        sh.cp( '-v', os.path.join( package_source_dir, 'bin/Release/Readme.txt' ), os.path.join( install_dir, 'Readme.meshy.txt' ) )
        sh.cp( '-v', '-r', os.path.join( package_source_dir, 'bin/Release_Linux/Resources/' ), install_dir )

        sh.mkdir( '-p', package_build_dir )
        sh.cd( package_build_dir )
        if ( platform.system() == 'Darwin' ):
            sh.cmake(
                '-G', 'Xcode',
                '-D', 'CMAKE_INSTALL_PREFIX=%s' % install_dir,
                '-D', 'CMAKE_MODULE_PATH=%s' % os.path.join( install_dir, 'CMake' ),
                package_source_dir,
                _out = sys.stdout )
            sh.xcodebuild( '-configuration', 'Release', _out = sys.stdout )
        else:
            sh.cmake(
                '-D', 'CMAKE_INSTALL_PREFIX=%s' % install_dir,
                '-D', 'CMAKE_MODULE_PATH=%s' % os.path.join( install_dir, 'lib/OGRE/cmake' ),
                package_source_dir,
                _out = sys.stdout )
            sh.make( '-j4', 'VERBOSE=1', _out = sys.stdout )
            sh.make.install( _out = sys.stdout )
Exemple #7
0
def build_opencv():
    sh.pip.install("numpy")
    clone_if_not_exists("opencv", "https://github.com/PolarNick239/opencv.git", branch="stable_3.0.0)
    clone_if_not_exists("opencv_contrib", "https://github.com/PolarNick239/opencv_contrib.git", branch="stable_3.0.0")
    sh.rm("-rf", "build")
    sh.mkdir("build")
    sh.cd("build")
    python_path = pathlib.Path(sh.pyenv.which("python").stdout.decode()).parent.parent
    version = "{}.{}".format(sys.version_info.major, sys.version_info.minor)
    sh.cmake(
        "..",
        "-DCMAKE_BUILD_TYPE=RELEASE",
        "-DCMAKE_INSTALL_PREFIX={}/usr/local".format(python_path),
        "-DWITH_CUDA=OFF",
        "-DWITH_FFMPEG=OFF",
        "-DINSTALL_C_EXAMPLES=OFF",
        "-DBUILD_opencv_legacy=OFF",
        "-DBUILD_NEW_PYTHON_SUPPORT=ON",
        "-DBUILD_opencv_python3=ON",
        "-DOPENCV_EXTRA_MODULES_PATH=~/opencv_contrib-3.4.1/modules",
        "-DBUILD_EXAMPLES=ON",
        "-DPYTHON_EXECUTABLE={}/bin/python".format(python_path),
        "-DPYTHON3_LIBRARY={}/lib/libpython{}m.so".format(python_path, version),
        "-DPYTHON3_PACKAGES_PATH={}/lib/python{}/site-packages/".format(python_path, version),
        "-DPYTHON3_NUMPY_INCLUDE_DIRS={}/lib/python{}/site-packages/numpy/core/include".format(python_path, version),
        "-DPYTHON_INCLUDE_DIR={}/include/python{}m".format(python_path, version),
        _out=sys.stdout,
    )
    sh.make("-j4", _out=sys.stdout)
    sh.make.install(_out=sys.stdout)
def _init_build_directory(config, initialised, directory, tute_directory, output=None, config_dict=PLAT_CONFIG):
    if not initialised:
        tute_dir = "-DTUTORIAL_DIR=" + os.path.basename(tute_directory)
        args = ['-DCMAKE_TOOLCHAIN_FILE=../kernel/gcc.cmake', '-G', 'Ninja'] + config_dict[config] + [tute_dir]
        result = sh.cmake(args + ['..'], _cwd = directory, _out=output, _err=output)
        if result.exit_code != 0:
            return result
        result = sh.cmake(['..'], _cwd = directory, _out=output, _err=output)
        if result.exit_code != 0:
            return result
    return sh.cmake(['..'], _cwd = directory, _out=output, _err=output)
Exemple #9
0
 def compile( self, source_dir, build_dir, install_dir ):
     package_source_dir = os.path.join( source_dir, self.dirname )
     assert( os.path.exists( package_source_dir ) )
     package_build_dir = os.path.join( build_dir, self.dirname )
     sh.mkdir( '-p', package_build_dir )
     sh.cd( package_build_dir )
     if ( platform.system() == 'Darwin' ):
         sh.cmake( '-G', 'Xcode', '-D', 'CMAKE_INSTALL_PREFIX=%s' % install_dir, package_source_dir, _out = sys.stdout )            
         sh.xcodebuild( '-scheme', 'install', '-configuration', 'Release', _out = sys.stdout )
     else:
         sh.cmake( '-D', 'CMAKE_INSTALL_PREFIX=%s' % install_dir, package_source_dir, _out = sys.stdout )
         sh.make( '-j4', 'VERBOSE=1', _out = sys.stdout )
         sh.make.install( _out = sys.stdout )
Exemple #10
0
def main():
    parser = argparse.ArgumentParser(
                description="Initialize a build directory for completing a tutorial. Invoke from "
                            "an empty sub directory, or the tutorials directory, in which case a "
                            "new build directory will be created for you.")

    parser.add_argument('--verbose', action='store_true',
                        help="Output everything including debug info", default=False)
    parser.add_argument('--quiet', action='store_true',
                        help="Suppress output except for tutorial completion information", default=True)
    parser.add_argument('--plat', type=str, choices=common.ALL_CONFIGS, required=True)
    parser.add_argument('--tut', type=str, choices=common.ALL_TUTORIALS, required=True)
    parser.add_argument('--solution', action='store_true', help="Generate pre-made solutions", default=False)
    args = parser.parse_args()
    common.setup_logger(__name__)
    common.set_log_level(args.verbose, True)
    # Additional config/tutorial combination validation
    if args.plat not in common.TUTORIALS[args.tut]:
        logging.error("Tutorial %s not supported by platform %s. Valid platforms are %s: ", args.tut, args.plat, common.TUTORIALS[args.tut])
        return -1
    # Check that the current working directory is empty. If not create a suitably
    # named build directory and switch to it
    if len(os.listdir(os.getcwd())) != 0:
        # Check that we are in the tutorial root directory before we decide to start
        # Making new directories
        if not os.access(os.getcwd() + "/init", os.X_OK):
            logging.error("Current dir %s is invalid" % os.getcwd())
            parser.print_help(sys.stderr)
            return -1
        build_dir = tempfile.mkdtemp(dir=os.getcwd(), prefix=('build_%s_%s' % (args.plat, args.tut)))
        os.chdir(build_dir)
    else:
        build_dir = None
    # Check that our parent directory is an expected tutorial root directory
    if not os.access(os.getcwd() + "/../init", os.X_OK):
        logging.error("Parent directory is not tutorials root directory")
        return -1
    # Initialize cmake. Output will be supressed as it defaults to the background
    result = common.init_build_directory(args.plat, args.tut, args.solution, os.getcwd())
    if result.exit_code != 0:
        logging.error("Failed to initialize build directory.")
        return -1
    # Run cmake again but show the tutorial information (to do this we run it in the foreground)
    sh.cmake(['-DTUTORIALS_PRINT_INSTRUCTIONS=TRUE', '..'], _fg=True)
    # Run again in the background but turn of printing
    sh.cmake(['-DTUTORIALS_PRINT_INSTRUCTIONS=FALSE', '..'])
    # Inform the user about any subdirectory we might have made
    if build_dir is not None:
        print("Tutorials created in subdirectory \"%s\". Switch to this directory and follow the instructions above to complete." % os.path.basename(build_dir))
    return 0
def setup(flamegraph_directory, flamegraph_path, perf_map_agent_path, java_home):
    """Setup deps for flamegraph"""

    # Create the flamegraph directory and clean the directory
    if not os.path.exists(flamegraph_directory):
        os.mkdir(flamegraph_directory)
    for f in os.listdir(flamegraph_directory):
        file_path = os.path.join(flamegraph_directory, f)
        sh.sudo.rm(file_path)

    if not os.path.exists(perf_map_agent_path):
        sh.git('clone', 'https://github.com/jrudolph/perf-map-agent', perf_map_agent_path)
        sh.cmake('.', _cwd=perf_map_agent_path, _env={'JAVA_HOME': java_home})
        sh.make(_cwd=perf_map_agent_path)

    if not os.path.exists(flamegraph_path):
        sh.git('clone', 'https://github.com/brendangregg/FlameGraph', flamegraph_path)
Exemple #12
0
	def build(self, branch, sourceDir, buildDir, rebuild):
		msgcmd("Building branch {}".format(branch))
		try:
			if not path.exists(buildDir):
				mkdir("-p", buildDir)
			elif path.exists(buildDir + "/bin") and rebuild:
				rm("-rf", buildDir + "/bin")

			cd(buildDir)
			cmake("-C", self.configFile, sourceDir, _out=debugSh, _err=debugSh)
			cd(sourceDir)
			make("BUILD_DIR=" + buildDir, "NPROCS=4", _out=debugSh, _err=debugSh)
		except ErrorReturnCode as e:
			msgerr("Failed build branch {}".format(branch))
			return False
		else:
			msgstat("Sucess build branch {}".format(branch))
			return True
Exemple #13
0
def build_host(extra_utilities):
    binaries = {}
    for utility in ["vfctrl_usb"] + extra_utilities:
        sh_print = lambda x: print_output(x, False)
        CMakeCache_file = host_utility_locations[utility] / "CMakeCache.txt"
        if CMakeCache_file.is_file():
            sh.rm(CMakeCache_file)
        print("Building %s..." % utility)
        with pushd(host_utility_locations[utility]):
            if utility != "vfctrl_json":
                sh.cmake(".")
            else:
                sh.cmake([".", "-DJSON=ON"])
            sh.make(_out=sh_print)
            print()
        path = host_utility_locations[utility] / "bin" / utility
        assert path.is_file()
        binaries[utility] = sh.Command(str(path))
    return binaries
Exemple #14
0
def check_cmake():
    """Check that cmake is installed."""
    from sh import which
    shOut = which('cmake')
    if not shOut is None:
        from sh import cmake
        version = str(cmake('--version'))
        return (version, True)
    else:
        return (None, False)
Exemple #15
0
def setup(flamegraph_directory, flamegraph_path, perf_map_agent_path,
          java_home):
    """Setup deps for flamegraph"""

    # Create the flamegraph directory and clean the directory
    if not os.path.exists(flamegraph_directory):
        os.mkdir(flamegraph_directory)
    for f in os.listdir(flamegraph_directory):
        file_path = os.path.join(flamegraph_directory, f)
        sh.sudo.rm(file_path)

    if not os.path.exists(perf_map_agent_path):
        sh.git('clone', 'https://github.com/jrudolph/perf-map-agent',
               perf_map_agent_path)
        sh.cmake('.', _cwd=perf_map_agent_path, _env={'JAVA_HOME': java_home})
        sh.make(_cwd=perf_map_agent_path)

    if not os.path.exists(flamegraph_path):
        sh.git('clone', 'https://github.com/brendangregg/FlameGraph',
               flamegraph_path)
Exemple #16
0
def build(version, to_build):
  saved_cwd = os.getcwd()

  root_directory = os.path.join(config.WORKING_DIRECTORY, version)
  source_directory = os.path.join(root_directory, config.SOURCE_PREFIX)
  
  for (compiler_name, targets) in to_build.items():
    directory = os.path.join(root_directory, compiler_name)
    build_directory = os.path.join(directory, config.BUILD_PREFIX)
    log_directory = os.path.join(directory, "log") 
    
    compiler = config.COMPILERS[compiler_name]
  
    try:
      os.makedirs(build_directory)
      os.mkdir(log_directory)
    except FileExistsError:
      # ignore -- we have already built before, directories exist
      pass
    os.chdir(build_directory)
    
    if not os.path.exists(os.path.join(build_directory, "CMakeCache.txt")):
      # N.B. Must NOT run CMake twice. This can break things!
      # In particular, CMake will think that the compilers are being changed
      # (even though they're remaining the same); it will issue a warning,
      # and hose the CMakeCache completely (e.g. compiler flags get reset)
      c_flags = compiler.get("flags", "") + " " + compiler.get("cflags", "")
      cxx_flags = compiler.get("flags", "") + " " + compiler.get("cxxflags", "")
      args = [source_directory, "-DCMAKE_BUILD_TYPE=Custom",
               "-DCMAKE_C_COMPILER=" + compiler["cc"], 
               "-DCMAKE_CXX_COMPILER=" + compiler["cxx"],
               "-DCMAKE_C_FLAGS_CUSTOM=" + c_flags,
               "-DCMAKE_CXX_FLAGS_CUSTOM=" + cxx_flags]
      sh.cmake(*args)
    
    # run make 
    sh.make(config.MAKE_FLAGS + list(targets), 
            _out=os.path.join(log_directory, "makefile.out"),
            _err=os.path.join(log_directory, "makefile.err"))
    
  os.chdir(saved_cwd)
Exemple #17
0
def BuildYcmdLibs( cmake_args ):
  build_dir = unicode( sh.mktemp( '-d', '-t', 'ycm_build.XXXXXX' ) ).strip()

  try:
    full_cmake_args = [ '-G', 'Unix Makefiles' ]
    if OnMac():
      full_cmake_args.extend( CustomPythonCmakeArgs() )
    full_cmake_args.extend( cmake_args )
    full_cmake_args.append( p.join( DIR_OF_THIS_SCRIPT, 'cpp' ) )

    sh.cd( build_dir )
    sh.cmake( *full_cmake_args, _out = sys.stdout )

    build_target = ( 'ycm_support_libs' if 'YCM_TESTRUN' not in os.environ else
                     'ycm_core_tests' )
    sh.make( '-j', NumCores(), build_target, _out = sys.stdout, _err = sys.stderr )

    if 'YCM_TESTRUN' in os.environ:
      RunYcmdTests( build_dir )
  finally:
    sh.cd( DIR_OF_THIS_SCRIPT )
    sh.rm( '-rf', build_dir )
Exemple #18
0
def _init_build_directory(config,
                          initialised,
                          directory,
                          tute_directory,
                          output=None,
                          config_dict=PLAT_CONFIG):
    args = []
    if not initialised:
        tute_dir = "-DTUTORIAL_DIR=" + os.path.basename(tute_directory)
        args = [
            '-DCMAKE_TOOLCHAIN_FILE=../kernel/gcc.cmake', '-G', 'Ninja'
        ] + config_dict[config] + [tute_dir] + ["-C", "../settings.cmake"]
    return sh.cmake(args + ['..'], _cwd=directory, _out=output, _err=output)
Exemple #19
0
    def compile(self, source_dir, build_dir, install_dir):
        package_source_dir = os.path.join(source_dir, self.dirname)
        assert (os.path.exists(package_source_dir))
        package_build_dir = os.path.join(build_dir, self.dirname)

        sh.cd(os.path.join(package_source_dir, 'scripts/Resources'))
        sh.sh('./copyresources.sh')
        # the install target doesn't copy the stuff that copyresources.sh puts in place
        sh.cp('-v', os.path.join(package_source_dir, 'bin/Release/Readme.txt'),
              os.path.join(install_dir, 'Readme.meshy.txt'))
        sh.cp('-v', '-r',
              os.path.join(package_source_dir, 'bin/Release_Linux/Resources/'),
              install_dir)

        sh.mkdir('-p', package_build_dir)
        sh.cd(package_build_dir)
        if (platform.system() == 'Darwin'):
            sh.cmake('-G',
                     'Xcode',
                     '-D',
                     'CMAKE_INSTALL_PREFIX=%s' % install_dir,
                     '-D',
                     'CMAKE_MODULE_PATH=%s' %
                     os.path.join(install_dir, 'CMake'),
                     package_source_dir,
                     _out=sys.stdout)
            sh.xcodebuild('-configuration', 'Release', _out=sys.stdout)
        else:
            sh.cmake('-D',
                     'CMAKE_INSTALL_PREFIX=%s' % install_dir,
                     '-D',
                     'CMAKE_MODULE_PATH=%s' %
                     os.path.join(install_dir, 'lib/OGRE/cmake'),
                     package_source_dir,
                     _out=sys.stdout)
            sh.make('-j4', 'VERBOSE=1', _out=sys.stdout)
            sh.make.install(_out=sys.stdout)
Exemple #20
0
def _init_build_directory(config,
                          initialised,
                          directory,
                          tute_directory,
                          output=None,
                          config_dict=PLAT_CONFIG):
    args = []
    if not initialised:
        tute_dir = "-DTUTORIAL_DIR=" + os.path.basename(tute_directory)
        args = ['-G', 'Ninja'] + config_dict[config] + [tute_dir] + \
            ["-C", "../projects/sel4-tutorials/settings.cmake"]
    return sh.cmake(args + [tute_directory],
                    _cwd=directory,
                    _out=output,
                    _err=output)
Exemple #21
0
def determine_compiler_name(compiler_executable_name):
    tmpdir = tempfile.gettempdir() + '/fruit-determine-compiler-version-dir'
    ensure_empty_dir(tmpdir)
    with open(tmpdir + '/CMakeLists.txt', 'w') as file:
        file.write('message("@@@${CMAKE_CXX_COMPILER_ID} ${CMAKE_CXX_COMPILER_VERSION}@@@")\n')
    modified_env = os.environ.copy()
    modified_env['CXX'] = compiler_executable_name
    # By converting to a list, we force all output to be read (so the command execution is guaranteed to be complete after this line).
    # Otherwise, subsequent calls to determine_compiler_name might have trouble deleting the temporary directory because the cmake
    # process is still writing files in there.
    cmake_output = list(sh.cmake('.', _cwd=tmpdir, _env=modified_env, _iter='err'))
    for line in cmake_output:
        re_result = re.search('@@@(.*)@@@', line)
        if re_result:
            pretty_name = re_result.group(1)
            # CMake calls GCC 'GNU', change it into 'GCC'.
            return pretty_name.replace('GNU ', 'GCC ')
    raise Exception('Unable to determine compiler. CMake output was: \n', cmake_output)
Exemple #22
0
def init_build_directory(config, tut, solution, directory, output=None):
    tut_arg = "-DTUTORIAL=" + tut
    args = ['-DCMAKE_TOOLCHAIN_FILE=../kernel/gcc.cmake', '-G', 'Ninja'
            ] + PLAT_CONFIG[config] + [tut_arg]
    if solution:
        args = args + ["-DBUILD_SOLUTIONS=TRUE"]
    result = sh.cmake(args + ['..'], _cwd=directory, _out=output)
    if result.exit_code != 0:
        return result
    sh.cmake(['..'], _cwd=directory, _out=output)
    if result.exit_code != 0:
        return result
    sh.cmake(['..'], _cwd=directory, _out=output)
    if result.exit_code != 0:
        return result
    return sh.cmake(['..'], _cwd=directory, _out=output)
#!/usr/bin/env python
from contextlib import contextmanager
import os
from sh import git, cmake, make, mv
import sys


@contextmanager
def cd(newdir):
    prevdir = os.getcwd()
    os.chdir(os.path.expanduser(newdir))
    try:
        yield
    finally:
        os.chdir(prevdir)


if __name__ == "__main__":
    # git clone
    with cd("tool"):
        print(cmake(".", _out=sys.stdout))
        print(make(_out=sys.stdout))
        mv("src/sigrefmc", "..")
        mv("src/sigrefmc_ht", "..")
Exemple #24
0
def main():
    # This configures numpy/scipy to raise an exception in case of errors, instead of printing a warning and going ahead.
    numpy.seterr(all='raise')
    scipy.seterr(all='raise')

    parser = argparse.ArgumentParser(
        description='Runs a set of benchmarks defined in a YAML file.')
    parser.add_argument(
        '--fruit-benchmark-sources-dir',
        help='Path to the fruit sources (used for benchmarking code only)')
    parser.add_argument('--fruit-sources-dir',
                        help='Path to the fruit sources')
    parser.add_argument('--boost-di-sources-dir',
                        help='Path to the Boost.DI sources')
    parser.add_argument(
        '--output-file',
        help=
        'The output file where benchmark results will be stored (1 per line, with each line in JSON format). These can then be formatted by e.g. the format_bench_results script.'
    )
    parser.add_argument(
        '--benchmark-definition',
        help=
        'The YAML file that defines the benchmarks (see fruit_wiki_benchs.yml for an example).'
    )
    args = parser.parse_args()

    if args.output_file is None:
        raise Exception('You must specify --output_file')
    sh.rm('-f', args.output_file)

    fruit_build_tmpdir = tempfile.gettempdir() + '/fruit-benchmark-build-dir'

    with open(args.benchmark_definition, 'r') as f:
        yaml_file_content = yaml.load(f)
        global_definitions = yaml_file_content['global']
        benchmark_definitions = expand_benchmark_definitions(
            yaml_file_content['benchmarks'])

    benchmark_index = 0

    all_compilers = {
        benchmarks_definition['compiler']
        for benchmarks_definition in benchmark_definitions
    }

    for compiler_executable_name in all_compilers:
        print('Preparing for benchmarks with the compiler %s' %
              compiler_executable_name)
        compiler_name = determine_compiler_name(compiler_executable_name)

        # Build Fruit in fruit_build_tmpdir, so that fruit_build_tmpdir points to a built Fruit (useful for e.g. the config header).
        shutil.rmtree(fruit_build_tmpdir, ignore_errors=True)
        os.makedirs(fruit_build_tmpdir)
        modified_env = os.environ.copy()
        modified_env['CXX'] = compiler_executable_name
        sh.cmake(args.fruit_sources_dir,
                 '-DCMAKE_BUILD_TYPE=Release',
                 _cwd=fruit_build_tmpdir,
                 _env=modified_env)
        make_command(_cwd=fruit_build_tmpdir)

        for benchmark_definition in benchmark_definitions:
            if benchmark_definition['compiler'] != compiler_executable_name:
                continue

            # The 'compiler_name' dimension is synthesized automatically from the 'compiler' dimension.
            # We put the compiler name/version in the results because the same 'compiler' value might refer to different compiler versions
            # (e.g. if GCC 6.0.0 is installed when benchmarks are run, then it's updated to GCC 6.0.1 and finally the results are formatted, we
            # want the formatted results to say "GCC 6.0.0" instead of "GCC 6.0.1").
            benchmark_definition = benchmark_definition.copy()
            benchmark_definition['compiler_name'] = compiler_name

            benchmark_index += 1
            print('%s/%s: %s' % (benchmark_index, len(benchmark_definitions),
                                 benchmark_definition))
            benchmark_name = benchmark_definition['name']

            if (benchmark_name in {
                    'boost_di_compile_time', 'boost_di_run_time',
                    'boost_di_executable_size'
            } and args.boost_di_sources_dir is None):
                raise Exception(
                    'Error: you need to specify the --boost-di-sources-dir flag in order to run Boost.DI benchmarks.'
                )

            if benchmark_name == 'new_delete_run_time':
                benchmark = NewDeleteRunTimeBenchmark(
                    benchmark_definition,
                    fruit_benchmark_sources_dir=args.
                    fruit_benchmark_sources_dir)
            elif benchmark_name == 'fruit_single_file_compile_time':
                benchmark = FruitSingleFileCompileTimeBenchmark(
                    benchmark_definition,
                    fruit_sources_dir=args.fruit_sources_dir,
                    fruit_benchmark_sources_dir=args.
                    fruit_benchmark_sources_dir,
                    fruit_build_tmpdir=fruit_build_tmpdir)
            elif benchmark_name == 'fruit_compile_time':
                benchmark = FruitCompileTimeBenchmark(
                    benchmark_definition,
                    fruit_sources_dir=args.fruit_sources_dir,
                    fruit_build_tmpdir=fruit_build_tmpdir)
            elif benchmark_name == 'fruit_run_time':
                benchmark = FruitRunTimeBenchmark(
                    benchmark_definition,
                    fruit_sources_dir=args.fruit_sources_dir,
                    fruit_build_tmpdir=fruit_build_tmpdir)
            elif benchmark_name == 'fruit_executable_size':
                benchmark = FruitExecutableSizeBenchmark(
                    benchmark_definition,
                    fruit_sources_dir=args.fruit_sources_dir,
                    fruit_build_tmpdir=fruit_build_tmpdir)
            elif benchmark_name == 'boost_di_compile_time':
                benchmark = BoostDiCompileTimeBenchmark(
                    benchmark_definition,
                    fruit_sources_dir=args.fruit_sources_dir,
                    fruit_build_tmpdir=fruit_build_tmpdir,
                    boost_di_sources_dir=args.boost_di_sources_dir)
            elif benchmark_name == 'boost_di_run_time':
                benchmark = BoostDiRunTimeBenchmark(
                    benchmark_definition,
                    fruit_sources_dir=args.fruit_sources_dir,
                    fruit_build_tmpdir=fruit_build_tmpdir,
                    boost_di_sources_dir=args.boost_di_sources_dir)
            elif benchmark_name == 'boost_di_executable_size':
                benchmark = BoostDiExecutableSizeBenchmark(
                    benchmark_definition,
                    fruit_sources_dir=args.fruit_sources_dir,
                    fruit_build_tmpdir=fruit_build_tmpdir,
                    boost_di_sources_dir=args.boost_di_sources_dir)
            else:
                raise Exception("Unrecognized benchmark: %s" % benchmark_name)

            run_benchmark(benchmark,
                          output_file=args.output_file,
                          max_runs=global_definitions['max_runs'])
Exemple #25
0
 def cmakeVT(self):
     cmake(*self.cmakeParams + ['..'], _out=_print_line, _err=_print_line)
#!/usr/bin/env python
from contextlib import contextmanager
import os
from sh import cmake, make, mv
import sys


@contextmanager
def cd(newdir):
    prevdir = os.getcwd()
    os.chdir(os.path.expanduser(newdir))
    try:
        yield
    finally:
        os.chdir(prevdir)


if __name__ == "__main__":
    # git clone
    with cd("tool"):
        print(cmake('.', _out=sys.stdout))
        print(make(_out=sys.stdout))
        mv("src/sigrefmc", "..")
        mv("src/sigrefmc_ht", "..")
Exemple #27
0
{fullcmd}

from {BUILDDIR} (i.e., CMake's config+generate stages).
Scroll up for details or look at the build log via

less -R {BUILDDIR}

Exiting...

""")

else:
    rich.print(f"The config+generate stage was skipped as CMakeCache.txt was already found in {BUILDDIR}")

if args.cmake_graphviz:
    output = sh.cmake(["--graphviz=graphviz/targets.dot", "."])
    sys.exit(output.exit_code)

if args.n_jobs:
    nprocs_argument = f"-j {args.n_jobs}"
else:
    nprocs = multiprocessing.cpu_count()
    nprocs_argument = f"-j {nprocs}"

    rich.print(f"This script believes you have {nprocs} processors available on this system, and will use as many of them as it can")

starttime_build_d=get_time("as_date")
starttime_build_s=get_time("as_seconds_since_epoch")

build_options=""
if args.cpp_verbose:
Exemple #28
0
        try:

            if gitCloneSuccFlag:
                print("git clone, successed, skip")
            else:
                print("git cloning...")
                sh.contrib.git.clone(cfg.repository, cfg.projectname)
                gitCloneSuccFlag = True

            sh.cd(cfg.projectname)

            if cmakeSuccFlag:
                print("cmake, successed, skip")
            else:
                print('cmake is running')
                sh.cmake('.')
                cmakeSuccFlag = True

            if makeSuccFlag:
                print("make, successed, skip")
            else:
                print('make is running...')
                sh.make('-j{}'.format(cfg.thread))
                makeSuccFlag = True

            break
        except Exception as e:
            print("Build Failed")
            print("Try : ", tryTimes)
            print('Exception Caught:', e)
Exemple #29
0
def main():
    # This configures numpy/scipy to raise an exception in case of errors, instead of printing a warning and going ahead.
    numpy.seterr(all='raise')
    scipy.seterr(all='raise')

    parser = argparse.ArgumentParser(description='Runs a set of benchmarks defined in a YAML file.')
    parser.add_argument('--fruit-benchmark-sources-dir', help='Path to the fruit sources (used for benchmarking code only)')
    parser.add_argument('--fruit-sources-dir', help='Path to the fruit sources')
    parser.add_argument('--boost-di-sources-dir', help='Path to the Boost.DI sources')
    parser.add_argument('--output-file',
                        help='The output file where benchmark results will be stored (1 per line, with each line in JSON format). These can then be formatted by e.g. the format_bench_results script.')
    parser.add_argument('--benchmark-definition', help='The YAML file that defines the benchmarks (see fruit_wiki_benchs_fruit.yml for an example).')
    parser.add_argument('--continue-benchmark', help='If this is \'true\', continues a previous benchmark run instead of starting from scratch (taking into account the existing benchmark results in the file specified with --output-file).')
    args = parser.parse_args()

    if args.output_file is None:
        raise Exception('You must specify --output_file')
    if args.continue_benchmark == 'true':
        with open(args.output_file, 'r') as f:
            previous_run_completed_benchmarks = [json.loads(line)['benchmark'] for line in f.readlines()]
    else:
        previous_run_completed_benchmarks = []
        sh.rm('-f', args.output_file)

    fruit_build_tmpdir = tempfile.gettempdir() + '/fruit-benchmark-build-dir'

    with open(args.benchmark_definition, 'r') as f:
        yaml_file_content = yaml.load(f)
        global_definitions = yaml_file_content['global']
        benchmark_definitions = expand_benchmark_definitions(yaml_file_content['benchmarks'])

    benchmark_index = 0

    all_compilers = {benchmarks_definition['compiler'] for benchmarks_definition in benchmark_definitions}

    for compiler_executable_name in all_compilers:
        print('Preparing for benchmarks with the compiler %s' % compiler_executable_name)
        # We compute this here (and memoize the result) so that the benchmark's describe() will retrieve the cached
        # value instantly.
        determine_compiler_name(compiler_executable_name)

        # Build Fruit in fruit_build_tmpdir, so that fruit_build_tmpdir points to a built Fruit (useful for e.g. the config header).
        shutil.rmtree(fruit_build_tmpdir, ignore_errors=True)
        os.makedirs(fruit_build_tmpdir)
        modified_env = os.environ.copy()
        modified_env['CXX'] = compiler_executable_name
        sh.cmake(args.fruit_sources_dir, '-DCMAKE_BUILD_TYPE=Release', _cwd=fruit_build_tmpdir, _env=modified_env)
        make_command(_cwd=fruit_build_tmpdir)

        for benchmark_definition in benchmark_definitions:
            if benchmark_definition['compiler'] != compiler_executable_name:
                continue

            benchmark_index += 1
            print('%s/%s: %s' % (benchmark_index, len(benchmark_definitions), benchmark_definition))
            benchmark_name = benchmark_definition['name']

            if (benchmark_name in {'boost_di_compile_time', 'boost_di_run_time', 'boost_di_executable_size'}
                and args.boost_di_sources_dir is None):
                raise Exception('Error: you need to specify the --boost-di-sources-dir flag in order to run Boost.DI benchmarks.')

            if benchmark_name == 'new_delete_run_time':
                benchmark = NewDeleteRunTimeBenchmark(
                    benchmark_definition,
                    fruit_benchmark_sources_dir=args.fruit_benchmark_sources_dir)
            elif benchmark_name == 'fruit_single_file_compile_time':
                benchmark = FruitSingleFileCompileTimeBenchmark(
                    benchmark_definition,
                    fruit_sources_dir=args.fruit_sources_dir,
                    fruit_benchmark_sources_dir=args.fruit_benchmark_sources_dir,
                    fruit_build_tmpdir=fruit_build_tmpdir)
            elif benchmark_name == 'fruit_compile_time':
                benchmark = FruitCompileTimeBenchmark(
                    benchmark_definition,
                    fruit_sources_dir=args.fruit_sources_dir,
                    fruit_build_tmpdir=fruit_build_tmpdir)
            elif benchmark_name == 'fruit_run_time':
                benchmark = FruitRunTimeBenchmark(
                    benchmark_definition,
                    fruit_sources_dir=args.fruit_sources_dir,
                    fruit_build_tmpdir=fruit_build_tmpdir)
            elif benchmark_name == 'fruit_executable_size':
                benchmark = FruitExecutableSizeBenchmark(
                    benchmark_definition,
                    fruit_sources_dir=args.fruit_sources_dir,
                    fruit_build_tmpdir=fruit_build_tmpdir)
            elif benchmark_name == 'boost_di_compile_time':
                benchmark = BoostDiCompileTimeBenchmark(
                    benchmark_definition,
                    fruit_sources_dir=args.fruit_sources_dir,
                    fruit_build_tmpdir=fruit_build_tmpdir,
                    boost_di_sources_dir=args.boost_di_sources_dir)
            elif benchmark_name == 'boost_di_run_time':
                benchmark = BoostDiRunTimeBenchmark(
                    benchmark_definition,
                    fruit_sources_dir=args.fruit_sources_dir,
                    fruit_build_tmpdir=fruit_build_tmpdir,
                    boost_di_sources_dir=args.boost_di_sources_dir)
            elif benchmark_name == 'boost_di_executable_size':
                benchmark = BoostDiExecutableSizeBenchmark(
                    benchmark_definition,
                    fruit_sources_dir=args.fruit_sources_dir,
                    fruit_build_tmpdir=fruit_build_tmpdir,
                    boost_di_sources_dir=args.boost_di_sources_dir)
            else:
                raise Exception("Unrecognized benchmark: %s" % benchmark_name)

            if benchmark.describe() in previous_run_completed_benchmarks:
                print("Skipping benchmark that was already run previously (due to --continue-benchmark):", benchmark.describe())
                continue

            run_benchmark(benchmark, output_file=args.output_file, max_runs=global_definitions['max_runs'])