mirror of
https://github.com/sched-ext/scx.git
synced 2024-11-24 20:00:22 +00:00
56bb963136
Rust build was using two separate workspaces - rust/ and scheds/rust. There's no reason to separate them and it makes doc generation tricky. Use single top level workspace so that we can drive all rust building from cargo.
411 lines
14 KiB
Meson
411 lines
14 KiB
Meson
project('sched_ext schedulers', 'c',
|
|
version: '1.0.4',
|
|
license: 'GPL-2.0',)
|
|
|
|
if meson.version().version_compare('<1.2')
|
|
error('meson >= 1.2 required')
|
|
endif
|
|
|
|
fs = import('fs')
|
|
|
|
cc = meson.get_compiler('c')
|
|
|
|
enable_rust = get_option('enable_rust')
|
|
|
|
bpf_clang = find_program(get_option('bpf_clang'))
|
|
|
|
run_veristat = find_program(join_paths(meson.current_source_dir(),
|
|
'meson-scripts/veristat'))
|
|
run_veristat_diff = find_program(join_paths(meson.current_source_dir(),
|
|
'meson-scripts/veristat_diff'))
|
|
|
|
enable_stress = get_option('enable_stress')
|
|
|
|
veristat_scheduler = get_option('veristat_scheduler')
|
|
|
|
veristat_diff_dir = get_option('veristat_diff_dir')
|
|
|
|
if enable_stress
|
|
run_stress_tests = find_program(join_paths(meson.current_source_dir(),
|
|
'meson-scripts/run_stress_tests'))
|
|
endif
|
|
|
|
get_clang_ver = find_program(join_paths(meson.current_source_dir(),
|
|
'meson-scripts/get_clang_ver'))
|
|
get_bpftool_ver = find_program(join_paths(meson.current_source_dir(),
|
|
'meson-scripts/get_bpftool_ver'))
|
|
bpftool_build_skel = find_program(join_paths(meson.current_source_dir(),
|
|
'meson-scripts/bpftool_build_skel'))
|
|
get_sys_incls = find_program(join_paths(meson.current_source_dir(),
|
|
'meson-scripts/get_sys_incls'))
|
|
test_sched = find_program(join_paths(meson.current_source_dir(),
|
|
'meson-scripts/test_sched'))
|
|
fetch_libbpf = find_program(join_paths(meson.current_source_dir(),
|
|
'meson-scripts/fetch_libbpf'))
|
|
build_libbpf = find_program(join_paths(meson.current_source_dir(),
|
|
'meson-scripts/build_libbpf'))
|
|
fetch_bpftool = find_program(join_paths(meson.current_source_dir(),
|
|
'meson-scripts/fetch_bpftool'))
|
|
build_bpftool = find_program(join_paths(meson.current_source_dir(),
|
|
'meson-scripts/build_bpftool'))
|
|
|
|
bpf_clang_ver = run_command(get_clang_ver, bpf_clang, check: true).stdout().strip()
|
|
if bpf_clang_ver == ''
|
|
error('Unable to find clang version')
|
|
endif
|
|
|
|
bpf_clang_maj = bpf_clang_ver.split('.')[0].to_int()
|
|
|
|
if bpf_clang_maj < 16
|
|
error('clang < 16 loses high 32 bits of 64 bit enums when compiling BPF (@0@ ver=@1@)'
|
|
.format(bpf_clang.full_path(), bpf_clang_ver))
|
|
elif bpf_clang_maj < 17
|
|
warning('clang >= 17 recommended (@0@ ver=@1@)'
|
|
.format(bpf_clang.full_path(), bpf_clang_ver))
|
|
endif
|
|
|
|
# These are for building libbpf and/or bpftool
|
|
|
|
if meson.get_compiler('c').get_id() == 'gcc'
|
|
extra_args = ['-Wno-sign-compare', '-Wno-maybe-uninitialized', '-Wno-calloc-transposed-args']
|
|
else
|
|
extra_args = []
|
|
endif
|
|
|
|
executable('cc_cflags_probe', 'meson-scripts/cc_cflags_probe.c', install: false, pie: true, c_args : extra_args)
|
|
|
|
jq = find_program('jq')
|
|
make = find_program('make')
|
|
nproc = find_program('nproc')
|
|
|
|
make_jobs = 1
|
|
if nproc.found()
|
|
make_jobs = run_command(nproc, check: true).stdout().to_int()
|
|
endif
|
|
|
|
libbpf_path = '@0@/libbpf'.format(meson.current_build_dir())
|
|
libbpf_src_path = '@0@/src'.format(libbpf_path)
|
|
libbpf_a = '@0@/libbpf.a'.format(libbpf_src_path)
|
|
should_build_libbpf = true
|
|
libbpf_h = get_option('libbpf_h')
|
|
libbpf_local_h = get_option('libbpf_h')
|
|
|
|
if get_option('libbpf_a') == 'disabled'
|
|
libbpf_a = ''
|
|
should_build_libbpf = false
|
|
elif get_option('libbpf_a') != ''
|
|
libbpf_a = get_option('libbpf_a')
|
|
if not fs.exists(libbpf_a)
|
|
error('@0@ does not exist.'.format(libbpf_a))
|
|
endif
|
|
should_build_libbpf = false
|
|
endif
|
|
|
|
# WARNING! To build libbpf with the same compiler(CC) and CFLAGS
|
|
# as the schedulers we need to do this hack whereby we create a dummy exe
|
|
# then read the compiler and args from meson's compile_commands.json
|
|
# and re-set them when we build libbpf with make
|
|
if should_build_libbpf
|
|
if not jq.found() or not make.found()
|
|
error('To build the libbpf library "make" and "jq" are required')
|
|
endif
|
|
|
|
libbpf_header_paths = ['/src/usr/include', '/include/uapi']
|
|
|
|
libbpf_h = []
|
|
|
|
# This exists because meson doesn't like absolute paths for include_directories
|
|
# if they are found within the same directory as the source
|
|
libbpf_local_h = []
|
|
local_build_path = meson.current_build_dir().replace(meson.current_source_dir(), '')
|
|
|
|
foreach path : libbpf_header_paths
|
|
libbpf_h += ['@0@'.format(libbpf_path) + path]
|
|
libbpf_local_h += ['.@0@/libbpf'.format(local_build_path) + path]
|
|
endforeach
|
|
|
|
message('Fetching libbpf repo')
|
|
libbpf_commit = '686f600bca59e107af4040d0838ca2b02c14ff50'
|
|
run_command(fetch_libbpf, meson.current_build_dir(), libbpf_commit, check: true)
|
|
|
|
make_jobs = 1
|
|
if nproc.found()
|
|
make_jobs = run_command(nproc, check: true).stdout().to_int()
|
|
endif
|
|
|
|
libbpf = custom_target('libbpf',
|
|
output: '@PLAINNAME@.__PHONY__',
|
|
input: 'meson-scripts/cc_cflags_probe.c',
|
|
command: [build_libbpf, jq, make, libbpf_src_path, '@0@'.format(make_jobs)],
|
|
build_by_default: true)
|
|
else
|
|
# this is a noop when we're not building libbpf ourselves
|
|
libbpf = custom_target('libbpf',
|
|
output: '@PLAINNAME@.__PHONY__',
|
|
input: 'meson-scripts/cc_cflags_probe.c',
|
|
command: ['echo'],
|
|
build_by_default: true)
|
|
endif
|
|
|
|
if libbpf_a != ''
|
|
libbpf_dep = [declare_dependency(
|
|
link_args: libbpf_a,
|
|
include_directories: libbpf_local_h),
|
|
cc.find_library('elf'),
|
|
cc.find_library('z'),
|
|
cc.find_library('zstd')]
|
|
else
|
|
libbpf_dep = dependency('libbpf', version: '>=1.4')
|
|
endif
|
|
|
|
if get_option('kernel_headers') != ''
|
|
kernel_headers = get_option('kernel_headers')
|
|
kernel_dep = [declare_dependency(include_directories: kernel_headers)]
|
|
else
|
|
kernel_dep = []
|
|
endif
|
|
|
|
bpftool_path = '@0@/bpftool/src'.format(meson.current_build_dir())
|
|
should_build_bpftool = true
|
|
bpftool_exe_path = '@0@/bpftool'.format(bpftool_path)
|
|
|
|
if get_option('bpftool') == 'disabled'
|
|
bpftool = find_program('bpftool')
|
|
should_build_bpftool = false
|
|
bpftool_exe_path = bpftool.full_path()
|
|
elif get_option('bpftool') != ''
|
|
bpftool = find_program(get_option('bpftool'))
|
|
should_build_bpftool = false
|
|
bpftool_exe_path = bpftool.full_path()
|
|
endif
|
|
|
|
if should_build_bpftool
|
|
message('Fetching bpftool repo')
|
|
bpftool_commit = '77a72987353fcae8ce330fd87d4c7afb7677a169'
|
|
run_command(fetch_bpftool, meson.current_build_dir(), bpftool_commit, check: true)
|
|
|
|
bpftool_target = custom_target('bpftool_target',
|
|
output: '@PLAINNAME@.__PHONY__',
|
|
input: 'meson-scripts/bpftool_dummy.c',
|
|
command: [build_bpftool, jq, make, bpftool_path, '@0@'.format(make_jobs)],
|
|
build_by_default: true)
|
|
else
|
|
bpftool_ver = run_command(get_bpftool_ver, bpftool_exe_path, check: true).stdout().strip()
|
|
bpftool_maj = bpftool_ver.split('.')[0].to_int()
|
|
bpftool_min = bpftool_ver.split('.')[1].to_int()
|
|
if bpftool_maj < 7 or (bpftool_maj == 7 and bpftool_min < 4)
|
|
error('bpftool >= 7.4 required (@0@ ver=@1@)'.format(bpftool_exe_path, bpftool_ver))
|
|
endif
|
|
# this is a noop when we're not building bpftool ourselves
|
|
bpftool_target = custom_target('bpftool_target',
|
|
output: '@PLAINNAME@.__PHONY__',
|
|
input: 'meson-scripts/bpftool_dummy.c',
|
|
command: ['echo'],
|
|
build_by_default: true)
|
|
endif
|
|
# end libbpf/bpftool stuff
|
|
|
|
#
|
|
# Determine bpf_base_cflags which will be used to compile all .bpf.o files.
|
|
# Note that "-target bpf" is not included to accommodate
|
|
# libbpf_cargo::SkeletonBuilder.
|
|
#
|
|
# Map https://mesonbuild.com/Reference-tables.html#cpu-families to the
|
|
# __TARGET_ARCH list in tools/lib/bpf/bpf_tracing.h in the kernel tree.
|
|
#
|
|
arch_dict = {
|
|
'x86': 'x86',
|
|
'x86_64': 'x86',
|
|
's390x': 's390',
|
|
'arm': 'arm',
|
|
'aarch64': 'arm64',
|
|
'mips': 'mips',
|
|
'mips64': 'mips',
|
|
'ppc': 'powerpc',
|
|
'ppc64': 'powerpc',
|
|
'sparc': 'sparc',
|
|
'sparc64': 'sparc',
|
|
'riscv32': 'riscv',
|
|
'riscv64': 'riscv',
|
|
'arc': 'arc',
|
|
'loongarch64': 'loongarch'
|
|
}
|
|
|
|
cpu = host_machine.cpu_family()
|
|
if cpu not in arch_dict
|
|
error('CPU family "@0@" is not in known arch dict'.format(cpu))
|
|
endif
|
|
|
|
sys_incls = run_command(get_sys_incls, bpf_clang, check: true).stdout().splitlines()
|
|
bpf_base_cflags = ['-g', '-O2', '-Wall', '-Wno-compare-distinct-pointer-types',
|
|
'-D__TARGET_ARCH_' + arch_dict[cpu], '-mcpu=v3',
|
|
'-m@0@-endian'.format(host_machine.endian())] + sys_incls
|
|
|
|
if get_option('werror')
|
|
bpf_base_cflags += '-Werror'
|
|
endif
|
|
|
|
message('cpu=@0@ bpf_base_cflags=@1@'.format(cpu, bpf_base_cflags))
|
|
|
|
libbpf_c_headers = []
|
|
|
|
if libbpf_a != ''
|
|
foreach header: libbpf_h
|
|
libbpf_c_headers += ['-I', header]
|
|
endforeach
|
|
endif
|
|
|
|
#
|
|
# Generators to build BPF skel file for C schedulers.
|
|
#
|
|
gen_bpf_o = generator(bpf_clang,
|
|
output: '@BASENAME@.o',
|
|
depends: [libbpf],
|
|
arguments: [bpf_base_cflags, '-target', 'bpf', libbpf_c_headers, '@EXTRA_ARGS@',
|
|
'-c', '@INPUT@', '-o', '@OUTPUT@'])
|
|
gen_bpf_skel = generator(bpftool_build_skel,
|
|
output: ['@BASENAME@.skel.h','@BASENAME@.subskel.h' ],
|
|
depends: [libbpf, bpftool_target],
|
|
arguments: [bpftool_exe_path, '@INPUT@', '@OUTPUT0@', '@OUTPUT1@'])
|
|
|
|
#
|
|
# For rust sub-projects.
|
|
#
|
|
cargo_build_args = ['--quiet']
|
|
if get_option('buildtype') == 'release' or get_option('buildtype') == 'plain'
|
|
cargo_build_args += '--release'
|
|
endif
|
|
|
|
if get_option('offline')
|
|
cargo_build_args += '--offline'
|
|
endif
|
|
|
|
if get_option('kernel') != ''
|
|
kernel = get_option('kernel')
|
|
endif
|
|
|
|
if enable_rust
|
|
cargo = find_program(get_option('cargo'))
|
|
cargo_fetch = find_program(join_paths(meson.current_source_dir(),
|
|
'meson-scripts/cargo_fetch'))
|
|
cargo_env = environment()
|
|
cargo_env.set('BPF_CLANG', bpf_clang.full_path())
|
|
|
|
meson.add_install_script('meson-scripts/install_rust_user_scheds')
|
|
|
|
foreach flag: bpf_base_cflags
|
|
cargo_env.append('BPF_BASE_CFLAGS', flag, separator: ' ')
|
|
endforeach
|
|
|
|
if libbpf_a != ''
|
|
foreach header: libbpf_h
|
|
cargo_env.append('BPF_EXTRA_CFLAGS_PRE_INCL', '-I' + header, separator: ' ')
|
|
endforeach
|
|
|
|
cargo_env.append('RUSTFLAGS',
|
|
'-C relocation-model=pic -C link-args=-lelf -C link-args=-lz -C link-args=-lzstd -L '
|
|
+ fs.parent(libbpf_a), separator: ' ')
|
|
|
|
#
|
|
# XXX - scx_rusty's original Cargo.toml contained a dependency matching
|
|
# the following. However, it doesn't seem necessary to enable linking to
|
|
# libbpf.a. Ask Dan Schatzberg about the role the dependency line plays.
|
|
#
|
|
#cargo_build_args += ['--config',
|
|
# 'dependencies.libbpf-sys.version="1.2"',
|
|
# '--config',
|
|
# 'dependencies.libbpf-sys.features=["novendor", "static"]']
|
|
endif
|
|
|
|
if get_option('cargo_home') != ''
|
|
cargo_env.set('CARGO_HOME', get_option('cargo_home'))
|
|
endif
|
|
|
|
run_target('fetch', command: [cargo_fetch, cargo], env: cargo_env)
|
|
|
|
rust_scheds = ['scx_lavd', 'scx_bpfland', 'scx_rustland', 'scx_rlfifo',
|
|
'scx_rusty',
|
|
'scx_layered'] # scx_mitosis temporarily excluded
|
|
rust_misc = ['scx_stats', 'scx_stats_derive', 'scx_utils',
|
|
'scx_rustland_core',
|
|
'scx_loader']
|
|
|
|
sched_deps = [libbpf, bpftool_target]
|
|
cargo_cmd = [cargo, 'build', '--manifest-path=@INPUT@', '--target-dir=@OUTDIR@',
|
|
cargo_build_args]
|
|
|
|
# target to compile all rust subprojects
|
|
custom_target('rust_all',
|
|
output: '@PLAINNAME@.__PHONY__',
|
|
input: 'Cargo.toml',
|
|
command: cargo_cmd,
|
|
env: cargo_env,
|
|
depends: sched_deps,
|
|
build_by_default: true,
|
|
build_always_stale: true)
|
|
|
|
# targets to build individual rust subprojects
|
|
foreach p : rust_scheds + rust_misc
|
|
custom_target(p,
|
|
output: p + '@PLAINNAME@.__PHONY__',
|
|
input: 'Cargo.toml',
|
|
command: cargo_cmd + ['-p', p],
|
|
env: cargo_env,
|
|
depends: sched_deps,
|
|
build_by_default: false,
|
|
build_always_stale: true)
|
|
endforeach
|
|
else
|
|
rust_scheds = []
|
|
endif
|
|
|
|
run_target('test_sched', command: [test_sched, kernel])
|
|
|
|
foreach s : rust_scheds
|
|
run_target('test_sched_'+s, command: [test_sched, kernel, s])
|
|
endforeach
|
|
|
|
run_target('veristat', command: [run_veristat, meson.current_build_dir(),
|
|
get_option('veristat_scheduler'), get_option('kernel')])
|
|
foreach s : rust_scheds
|
|
run_target('veristat_'+s, command: [run_veristat, meson.current_build_dir(),
|
|
get_option('veristat_scheduler'), get_option('kernel'), s])
|
|
endforeach
|
|
|
|
run_target('veristat_diff', command: [run_veristat_diff, meson.current_build_dir(),
|
|
get_option('veristat_scheduler'), get_option('kernel'),
|
|
get_option('veristat_diff_dir')])
|
|
|
|
if enable_stress
|
|
run_target('stress_tests', command: [run_stress_tests, '-k', kernel, '-b',
|
|
meson.current_build_dir()])
|
|
foreach s : rust_scheds
|
|
run_target('stress_tests_'+s, command: [run_stress_tests, '-k', kernel, '-b',
|
|
meson.current_build_dir(), '--sched', s])
|
|
endforeach
|
|
endif
|
|
|
|
subdir('scheds')
|
|
|
|
systemd = dependency('systemd', required: get_option('systemd'))
|
|
|
|
if systemd.found()
|
|
subdir('services/systemd')
|
|
endif
|
|
|
|
openrc = dependency('openrc', required: get_option('openrc'))
|
|
|
|
if openrc.found()
|
|
subdir('services/openrc')
|
|
endif
|
|
|
|
libalpm = dependency('libalpm', required: get_option('libalpm'))
|
|
|
|
if libalpm.found() and systemd.found()
|
|
subdir('libalpm/systemd')
|
|
endif
|
|
|
|
if libalpm.found() and openrc.found()
|
|
subdir('libalpm/openrc')
|
|
endif
|