mirror of
https://github.com/ArduPilot/ardupilot
synced 2025-01-08 08:58:29 -04:00
f338b917d0
If there's no variant configuration, then cfg.variant will be '', which will make bldnode be cfg.bldnode. Thus, this patch prepare gbenchmark build for variant builds and doesn't break the current build.
136 lines
4.4 KiB
Python
136 lines
4.4 KiB
Python
#!/usr/bin/env python
|
|
# encoding: utf-8
|
|
|
|
"""
|
|
gbenchmark is a Waf tool for benchmark builds in Ardupilot
|
|
"""
|
|
|
|
from waflib import Build, Context, Task
|
|
from waflib.TaskGen import feature, before_method, after_method
|
|
from waflib.Errors import WafError
|
|
|
|
def configure(cfg):
|
|
env = cfg.env
|
|
env.HAS_GBENCHMARK = False
|
|
|
|
cfg.start_msg('Checking for gbenchmark submodule')
|
|
cmake_lists = cfg.srcnode.find_resource('modules/gbenchmark/CMakeLists.txt')
|
|
if not cmake_lists:
|
|
cfg.end_msg('not initialized', color='YELLOW')
|
|
return
|
|
cfg.end_msg('yes')
|
|
|
|
cfg.find_program('cmake', mandatory=False)
|
|
|
|
if not env.CMAKE:
|
|
return
|
|
|
|
env.GBENCHMARK_CMAKE_GENERATOR = None
|
|
|
|
cfg.find_program(['ninja', 'ninja-build'], var='NINJA', mandatory=False)
|
|
if env.NINJA:
|
|
env.GBENCHMARK_CMAKE_GENERATOR = 'Ninja'
|
|
|
|
env.GBENCHMARK_GENERATOR_OPTION = ''
|
|
if env.GBENCHMARK_CMAKE_GENERATOR:
|
|
env.GBENCHMARK_GENERATOR_OPTION = '-G%s' % env.GBENCHMARK_CMAKE_GENERATOR
|
|
|
|
bldnode = cfg.bldnode.make_node(cfg.variant)
|
|
prefix_node = bldnode.make_node('gbenchmark')
|
|
my_build_node = bldnode.make_node('gbenchmark_build')
|
|
my_src_node = cfg.srcnode.find_dir('modules/gbenchmark')
|
|
|
|
env.GBENCHMARK_PREFIX_REL = prefix_node.path_from(bldnode)
|
|
env.GBENCHMARK_BUILD = my_build_node.abspath()
|
|
env.GBENCHMARK_BUILD_REL = my_build_node.path_from(bldnode)
|
|
env.GBENCHMARK_SRC = my_src_node.abspath()
|
|
|
|
env.INCLUDES_GBENCHMARK = [prefix_node.make_node('include').abspath()]
|
|
env.LIBPATH_GBENCHMARK = [prefix_node.make_node('lib').abspath()]
|
|
env.LIB_GBENCHMARK = ['benchmark']
|
|
|
|
env.HAS_GBENCHMARK = True
|
|
|
|
class gbenchmark_build(Task.Task):
|
|
def __init__(self, *k, **kw):
|
|
super(gbenchmark_build, self).__init__(*k, **kw)
|
|
|
|
bldnode = self.generator.bld.bldnode
|
|
output_list = [
|
|
'%s/%s' % (self.env.GBENCHMARK_PREFIX_REL, path)
|
|
for path in (
|
|
'include/benchmark/benchmark.h',
|
|
'include/benchmark/macros.h',
|
|
'include/benchmark/benchmark_api.h',
|
|
'include/benchmark/reporter.h',
|
|
'lib/libbenchmark.a',
|
|
)
|
|
]
|
|
self.outputs.extend([bldnode.make_node(f) for f in output_list])
|
|
|
|
def run(self):
|
|
bld = self.generator.bld
|
|
cmds = []
|
|
|
|
cmake_lists = bld.srcnode.find_resource('modules/gbenchmark/CMakeLists.txt')
|
|
if not cmake_lists:
|
|
bld.fatal('Submodule gbenchmark not initialized, please run configure again')
|
|
|
|
# Generate build system first, if necessary
|
|
my_build_node = bld.bldnode.find_dir(self.env.GBENCHMARK_BUILD_REL)
|
|
if not (my_build_node and my_build_node.find_resource('CMakeCache.txt')):
|
|
if not my_build_node:
|
|
bld.bldnode.make_node(self.env.GBENCHMARK_BUILD_REL).mkdir()
|
|
|
|
cmds.append('%s %s -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX:PATH=%s %s' % (
|
|
self.env.CMAKE[0],
|
|
self.env.GBENCHMARK_SRC,
|
|
bld.bldnode.make_node(self.env.GBENCHMARK_PREFIX_REL).abspath(),
|
|
self.env.GBENCHMARK_GENERATOR_OPTION
|
|
))
|
|
|
|
cmds.append('%s --build %s --target install' % (
|
|
self.env.CMAKE[0],
|
|
self.env.GBENCHMARK_BUILD
|
|
))
|
|
try:
|
|
for cmd in cmds:
|
|
bld.cmd_and_log(
|
|
cmd,
|
|
cwd=self.env.GBENCHMARK_BUILD,
|
|
quiet=Context.BOTH,
|
|
)
|
|
return 0
|
|
except WafError as e:
|
|
print(e)
|
|
if hasattr(e, 'stderr'):
|
|
print('')
|
|
print(e.stderr)
|
|
return 1
|
|
|
|
def __str__(self):
|
|
return 'Google Benchmark'
|
|
|
|
gbenchmark_build = Task.always_run(Task.update_outputs(gbenchmark_build))
|
|
|
|
build_task = None
|
|
|
|
@feature('gbenchmark')
|
|
@before_method('process_use')
|
|
def append_gbenchmark_use(self):
|
|
self.use = self.to_list(getattr(self, 'use', []))
|
|
if 'GBENCHMARK' not in self.use:
|
|
self.use.append('GBENCHMARK')
|
|
|
|
@feature('gbenchmark')
|
|
@after_method('process_source')
|
|
def wait_for_gbenchmark_build(self):
|
|
global build_task
|
|
|
|
if not build_task:
|
|
build_task = self.create_task('gbenchmark_build')
|
|
|
|
for task in self.compiled_tasks:
|
|
task.set_run_after(build_task)
|
|
task.dep_nodes.extend(build_task.outputs)
|