pax_global_header 0000666 0000000 0000000 00000000064 15007705772 0014524 g ustar 00root root 0000000 0000000 52 comment=091a2ade2f26fa6d87047b4ce2ba850fe0d0ca37
scx-1.0.12/ 0000775 0000000 0000000 00000000000 15007705772 0012402 5 ustar 00root root 0000000 0000000 scx-1.0.12/.clangd 0000664 0000000 0000000 00000000160 15007705772 0013630 0 ustar 00root root 0000000 0000000 CompileFlags:
Add: [-DLSP, -Wno-missing-declarations, -Wno-typedef-redefinition, -Wno-ignored-attributes, -xc] scx-1.0.12/.editorconfig 0000664 0000000 0000000 00000000327 15007705772 0015061 0 ustar 00root root 0000000 0000000 # SPDX-License-Identifier: GPL-2.0-only
root = true
[{*.{awk,c,dts,dtsi,dtso,h,mk,s,S},Kconfig,Makefile,Makefile.*}]
charset = utf-8
end_of_line = lf
insert_final_newline = true
indent_style = tab
indent_size = 8
scx-1.0.12/.githooks/ 0000775 0000000 0000000 00000000000 15007705772 0014307 5 ustar 00root root 0000000 0000000 scx-1.0.12/.githooks/pre-commit 0000775 0000000 0000000 00000000211 15007705772 0016303 0 ustar 00root root 0000000 0000000 #!/bin/sh
echo "Running cargo fmt..."
cargo fmt --all
# Stage any files modified by cargo fmt
git add $(git diff --name-only)
exit 0
scx-1.0.12/.github/ 0000775 0000000 0000000 00000000000 15007705772 0013742 5 ustar 00root root 0000000 0000000 scx-1.0.12/.github/actions/ 0000775 0000000 0000000 00000000000 15007705772 0015402 5 ustar 00root root 0000000 0000000 scx-1.0.12/.github/actions/install-deps-action/ 0000775 0000000 0000000 00000000000 15007705772 0021254 5 ustar 00root root 0000000 0000000 scx-1.0.12/.github/actions/install-deps-action/action.yml 0000664 0000000 0000000 00000003147 15007705772 0023261 0 ustar 00root root 0000000 0000000 name: install-deps
runs:
using: 'composite'
steps:
### OTHER REPOS ####
# turn off interactive, refresh pkgs
- run: |
echo 'debconf debconf/frontend select Noninteractive' | sudo debconf-set-selections
sudo rm /var/lib/man-db/auto-update
sudo apt-get update -y
sudo apt-get install -y tasksel
sudo tasksel remove ubuntu-desktop
shell: bash
### DOWNLOAD AND INSTALL DEPENDENCIES ###
# Download dependencies packaged by Ubuntu
- run: |
sudo apt install -f -y bison busybox-static cmake coreutils \
cpio elfutils file flex gcc gcc-multilib git iproute2 jq kbd kmod \
libcap-dev libelf-dev libunwind-dev libvirt-clients libzstd-dev \
linux-headers-generic linux-tools-common linux-tools-generic make \
ninja-build pahole pkg-config python3-dev python3-pip python3-requests \
qemu-kvm rsync stress-ng udev zstd libseccomp-dev libcap-ng-dev \
llvm-19 clang-19 python3-full curl meson bpftrace dwarves rustup \
protobuf-compiler
echo /usr/lib/llvm-19/bin >> $GITHUB_PATH
shell: bash
# ensure some toolchain is installed
- run: |
rustup default nightly
shell: bash
# virtme-ng
- run: sudo pip3 install virtme-ng --break-system-packages
shell: bash
# Setup KVM support
- run: |
echo 'KERNEL=="kvm", GROUP="kvm", MODE="0666", OPTIONS+="static_node=kvm"' | sudo tee /etc/udev/rules.d/99-kvm4all.rules
sudo udevadm control --reload-rules
sudo udevadm trigger --name-match=kvm
shell: bash
### END DEPENDENCIES ###
scx-1.0.12/.github/actions/restore-kernel-cache/ 0000775 0000000 0000000 00000000000 15007705772 0021404 5 ustar 00root root 0000000 0000000 scx-1.0.12/.github/actions/restore-kernel-cache/action.yml 0000664 0000000 0000000 00000001226 15007705772 0023405 0 ustar 00root root 0000000 0000000 name: 'Restore kernel cache'
description: 'Restore a previously built kernel cache, failing if not available'
inputs:
repo-name:
required: true
type: string
runs:
using: "composite"
steps:
- name: Get hash from repo/branch
run: echo "SCHED_EXT_KERNEL_COMMIT=$(jq -r '."${{ inputs.repo-name }}".commitHash' kernel-versions.json)" >> $GITHUB_ENV
shell: bash
- name: Load cache
uses: actions/cache/restore@v4
with:
fail-on-cache-miss: true
key: kernel-build-${{ env.SCHED_EXT_KERNEL_COMMIT }}-7
path: |
linux/arch/x86/boot/bzImage
linux/usr/include
linux/**/*.h
scx-1.0.12/.github/include/ 0000775 0000000 0000000 00000000000 15007705772 0015365 5 ustar 00root root 0000000 0000000 scx-1.0.12/.github/include/build-kernel.nix 0000664 0000000 0000000 00000001267 15007705772 0020470 0 ustar 00root root 0000000 0000000 { lib
, stdenv
, fetchgit
, virtme-ng
, linuxManualConfig
, linuxPackages_latest
, name
, repo
, branch
, commitHash
, narHash
, version
}:
let
src = fetchgit {
url = repo;
rev = commitHash;
branchName = branch;
hash = narHash;
};
configfile = stdenv.mkDerivation {
inherit src;
name = name + "-configfile";
buildInputs = linuxPackages_latest.kernel.buildInputs;
nativeBuildInputs = linuxPackages_latest.kernel.nativeBuildInputs;
buildPhase = ''
${virtme-ng}/bin/virtme-ng -v --kconfig --config ${./sched-ext.config}
'';
installPhase = ''
mv .config $out
'';
};
in
linuxManualConfig {
inherit src version configfile;
}
scx-1.0.12/.github/include/ci.py 0000775 0000000 0000000 00000012271 15007705772 0016340 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python3
import argparse
import json
import os
import random
import subprocess
import sys
from typing import List, Optional
def run_command(
cmd: List[str],
check: bool = True,
env: Optional[dict] = None,
cwd: Optional[str] = None,
) -> subprocess.CompletedProcess:
"""Run a command and return the result."""
print(f"Running: {' '.join(cmd)}", flush=True)
merged_env = os.environ.copy()
if env:
merged_env.update(env)
return subprocess.run(cmd, check=check, env=merged_env, cwd=cwd)
def get_clippy_packages() -> List[str]:
"""Get list of packages that should be linted with clippy."""
result = subprocess.run(
["cargo", "metadata", "--format-version", "1"],
check=True,
capture_output=True,
text=True,
)
metadata = json.loads(result.stdout)
clippy_packages = []
for pkg in metadata.get("packages", []):
pkg_metadata = pkg.get("metadata")
if pkg_metadata:
scx_metadata = pkg_metadata.get("scx")
if scx_metadata and scx_metadata.get("ci", {}).get("use_clippy") == True:
clippy_packages.append(pkg["name"])
return clippy_packages
def run_format():
"""Format all targets."""
print("Running format...", flush=True)
run_command(["black", ".github/include/ci.py"])
run_command(["isort", ".github/include/ci.py"])
run_command(["cargo", "fmt"])
run_command(
["nix", "--extra-experimental-features", "nix-command flakes", "fmt"],
cwd=".github/include",
)
run_command(["git", "diff", "--exit-code"])
print("✓ Format completed successfully", flush=True)
def run_build():
"""Build all targets."""
print("Running build...", flush=True)
run_command(["cargo", "build", "--all-targets"])
print("✓ Build completed successfully", flush=True)
def run_clippy():
"""Run clippy on packages marked for CI linting."""
print("Running clippy...", flush=True)
clippy_packages = get_clippy_packages()
for package in clippy_packages:
run_command(["cargo", "clippy", "--no-deps", "-p", package, "--", "-Dwarnings"])
print("✓ Clippy checks passed", flush=True)
def run_tests():
"""Run the test suite."""
print("Running tests...", flush=True)
result = subprocess.run(
[
"cargo",
"nextest",
"archive",
"--archive-file",
"target/nextest-archive.tar.zst",
],
check=True,
stdout=subprocess.PIPE,
stderr=sys.stderr,
text=True,
)
# Get CPU count
cpu_count = min(os.cpu_count(), 16)
# Find kernel image
kernel_path = "linux/arch/x86/boot/bzImage"
if not os.path.exists(kernel_path):
print(f"Error: Kernel image not found at {kernel_path}")
print("Make sure to run the build-kernel job first")
sys.exit(1)
cmd = [
"vng",
"--memory",
"10G",
"--cpu",
str(cpu_count),
"-r",
kernel_path,
]
if os.environ.get("CI") == "true":
# verbose in CI but not locally
cmd += ["-v"]
# CI runs in /var/cache/private which fails the usual cwd stuff. mount
# it elsewhere and use that as the root.
cmd += [
"--overlay-rwdir=/tmp",
"--rodir=/tmp/workspace=.",
"--cwd=/tmp/workspace",
]
cmd += [
"--",
sys.argv[0],
"test-in-vm",
]
# Run tests in VM
run_command(cmd)
print("✓ Tests completed successfully", flush=True)
def run_tests_in_vm():
"""Run tests when already inside the VM."""
run_command(
[
"cargo-nextest",
"nextest",
"run",
"--archive-file",
"target/nextest-archive.tar.zst",
"--workspace-remap",
".",
"--no-fail-fast",
]
)
def run_all():
"""Run all CI steps in the correct order."""
run_format()
run_build()
run_clippy()
run_tests()
def main():
parser = argparse.ArgumentParser(description="SCX CI Script")
subparsers = parser.add_subparsers(
dest="command", description="Command to run (default: all)"
)
subparsers.required = True
parser_format = subparsers.add_parser("format", help="Perform formatting checks")
parser_build = subparsers.add_parser("build", help="Build Rust crates")
parser_clippy = subparsers.add_parser(
"clippy", help="Run Clippy on crates that request it"
)
parser_test = subparsers.add_parser("test", help="Run Rust tests")
parser_all = subparsers.add_parser("all", help="Run all commands")
parser_test_in_vm = subparsers.add_parser(
"test-in-vm",
help="Run Rust tests in VM (intended to be invoked by this script)",
)
args = parser.parse_args()
if args.command == "format":
run_format()
elif args.command == "build":
run_build()
elif args.command == "clippy":
run_clippy()
elif args.command == "test":
run_tests()
elif args.command == "test-in-vm":
run_tests_in_vm()
elif args.command == "all":
run_all()
if __name__ == "__main__":
main()
scx-1.0.12/.github/include/flake.lock 0000664 0000000 0000000 00000004016 15007705772 0017322 0 ustar 00root root 0000000 0000000 {
"nodes": {
"flake-utils": {
"inputs": {
"systems": "systems"
},
"locked": {
"lastModified": 1731533236,
"narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
"owner": "numtide",
"repo": "flake-utils",
"rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
"type": "github"
},
"original": {
"owner": "numtide",
"repo": "flake-utils",
"type": "github"
}
},
"nix-develop-gha": {
"inputs": {
"nixpkgs": [
"nixpkgs"
]
},
"locked": {
"lastModified": 1740956892,
"narHash": "sha256-9MhGx2h0/iE2xF9SOw4QaQNfSM0KXvkUBNJZ5NYLb1I=",
"owner": "nicknovitski",
"repo": "nix-develop",
"rev": "5da6ac475f1ffbcf54ee562fa3056646e146be95",
"type": "github"
},
"original": {
"owner": "nicknovitski",
"repo": "nix-develop",
"type": "github"
}
},
"nixpkgs": {
"locked": {
"lastModified": 1745583952,
"narHash": "sha256-ybjWNaiScS4XCT4PYYXyXg5sWxQBWzIr7UkoLiB667U=",
"owner": "JakeHillion",
"repo": "nixpkgs",
"rev": "93043a431a3a709df655ae9d8f95af129d9b832f",
"type": "github"
},
"original": {
"owner": "JakeHillion",
"ref": "virtme-ng",
"repo": "nixpkgs",
"type": "github"
}
},
"root": {
"inputs": {
"flake-utils": "flake-utils",
"nix-develop-gha": "nix-develop-gha",
"nixpkgs": "nixpkgs"
}
},
"systems": {
"locked": {
"lastModified": 1681028828,
"narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
"owner": "nix-systems",
"repo": "default",
"rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
"type": "github"
},
"original": {
"owner": "nix-systems",
"repo": "default",
"type": "github"
}
}
},
"root": "root",
"version": 7
}
scx-1.0.12/.github/include/flake.nix 0000664 0000000 0000000 00000012720 15007705772 0017171 0 ustar 00root root 0000000 0000000 {
description = "Nix flake for the scx CI environment.";
inputs = {
nixpkgs.url = "github:JakeHillion/nixpkgs/virtme-ng";
flake-utils.url = "github:numtide/flake-utils";
nix-develop-gha.url = "github:nicknovitski/nix-develop";
nix-develop-gha.inputs.nixpkgs.follows = "nixpkgs";
};
outputs = { self, nixpkgs, flake-utils, nix-develop-gha, ... }:
flake-utils.lib.eachSystem [ "x86_64-linux" ]
(system:
let
pkgs = import nixpkgs { inherit system; };
lib = pkgs.lib;
in
{
devShells =
let
common = with pkgs; [ git gnutar zstd ];
in
{
restore-kernels = pkgs.mkShellNoCC {
buildInputs = with pkgs; common ++ [
jq
];
};
update-kernels = pkgs.mkShell {
buildInputs = with pkgs; common ++ [
gh
git
jq
];
};
list-tests = pkgs.mkShell {
buildInputs = with pkgs; common ++ [
python3
];
};
build-kernel = pkgs.mkShell {
buildInputs = with pkgs; common ++ [
bc
bison
cpio
elfutils
flex
git
jq
openssl
pahole
perl
virtme-ng
zlib
];
};
};
packages = {
nix-develop-gha = nix-develop-gha.packages."${system}".default;
kernels = builtins.mapAttrs
(name: details: (pkgs.callPackage ./build-kernel.nix {
inherit name;
inherit (details) repo branch commitHash narHash;
version = details.kernelVersion;
}))
(builtins.fromJSON (builtins.readFile ./../../kernel-versions.json));
ci =
pkgs.python3Packages.buildPythonApplication rec {
pname = "ci";
version = "git";
pyproject = false;
dontUnpack = true;
propagatedBuildInputs = with pkgs; [
bash
binutils
black
cargo
cargo-nextest
clang
clippy
coreutils
gcc
git
gnugrep
gnumake
gnused
isort
jq
libseccomp.lib
llvmPackages.libclang
llvmPackages.libllvm
pkg-config
protobuf
rustc
rustfmt
virtme-ng
elfutils.dev
zlib.dev
zstd.dev
];
makeWrapperArgs = lib.lists.flatten [
[ "--set" "CC" "gcc" ]
[ "--set" "LD" "ld" ]
[ "--set" "BPF_CLANG" (lib.getExe pkgs.llvmPackages.clang) ]
[ "--set" "LIBCLANG_PATH" "${lib.getLib pkgs.llvmPackages.libclang}/lib" ]
[ "--set" "PKG_CONFIG_PATH" "${lib.makeSearchPath "lib/pkgconfig" propagatedBuildInputs}" ]
[ "--set" "RUSTFLAGS" "'-C relocation-model=pic -C link-args=-lelf -C link-args=-lz -C link-args=-lzstd'" ]
[ "--set" "NIX_BINTOOLS" pkgs.binutils ]
[ "--set" "NIX_CC" pkgs.gcc ]
(
let system = builtins.replaceStrings [ "-" ] [ "_" ] pkgs.stdenv.hostPlatform.config; in [
[ "--set" "NIX_BINTOOLS_WRAPPER_TARGET_HOST_${system}" "1" ]
[ "--set" "NIX_CC_WRAPPER_TARGET_HOST_${system}" "1" ]
[ "--set" "NIX_PKG_CONFIG_WRAPPER_TARGET_HOST_${system}" "1" ]
]
)
[
"--set"
"NIX_LDFLAGS"
("'" + (lib.concatStringsSep " " (builtins.map (drv: "-L${drv}/lib") (with pkgs; [
elfutils.out
zlib
zstd.out
libseccomp.lib
]))) + "'")
]
];
installPhase = "install -Dm755 ${../include/ci.py} $out/bin/ci";
};
};
}) // flake-utils.lib.eachDefaultSystem (system:
let
pkgs = import nixpkgs { inherit system; };
in
{
formatter = pkgs.nixpkgs-fmt;
apps = {
update-kernels =
let
script = pkgs.python3Packages.buildPythonApplication {
pname = "update-kernels";
version = "git";
pyproject = false;
dontUnpack = true;
dependencies = with pkgs; [
bash
coreutils
git
gnumake
gnused
nix
];
installPhase = "install -Dm755 ${../include/update-kernels.py} $out/bin/update-kernels";
};
in
{
type = "app";
program = "${script}/bin/update-kernels";
};
};
});
}
scx-1.0.12/.github/include/sched-ext.config 0000664 0000000 0000000 00000002531 15007705772 0020441 0 ustar 00root root 0000000 0000000 # sched-ext mandatory options
#
CONFIG_BPF=y
CONFIG_BPF_SYSCALL=y
CONFIG_BPF_JIT=y
CONFIG_DEBUG_INFO_BTF=y
CONFIG_BPF_JIT_ALWAYS_ON=y
CONFIG_BPF_JIT_DEFAULT_ON=y
CONFIG_SCHED_CLASS_EXT=y
# Required on arm64
#
# CONFIG_DEBUG_INFO_REDUCED is not set
# Enable scheduling debugging
#
CONFIG_SCHED_DEBUG=y
# Enable extra scheduling features (for a better code coverage while testing
# the schedulers)
#
CONFIG_SCHED_AUTOGROUP=y
CONFIG_SCHED_CORE=y
CONFIG_SCHED_MC=y
# Enable fully preemptible kernel for a better test coverage of the schedulers
#
# CONFIG_PREEMPT_NONE is not set
# CONFIG_PREEMPT_VOLUNTARY is not set
CONFIG_PREEMPT=y
CONFIG_PREEMPT_COUNT=y
CONFIG_PREEMPTION=y
CONFIG_PREEMPT_DYNAMIC=y
CONFIG_PREEMPT_RCU=y
# Additional debugging information (useful to catch potential locking issues)
#
CONFIG_DEBUG_LOCKDEP=y
CONFIG_DEBUG_ATOMIC_SLEEP=y
CONFIG_PROVE_LOCKING=y
# Bpftrace headers (for additional debug info)
CONFIG_BPF=y
CONFIG_BPF_SYSCALL=y
CONFIG_BPF_JIT=y
CONFIG_HAVE_EBPF_JIT=y
CONFIG_BPF_EVENTS=y
CONFIG_FTRACE_SYSCALLS=y
CONFIG_FUNCTION_TRACER=y
CONFIG_HAVE_DYNAMIC_FTRACE=y
CONFIG_DYNAMIC_FTRACE=y
CONFIG_HAVE_KPROBES=y
CONFIG_KPROBES=y
CONFIG_KPROBE_EVENTS=y
CONFIG_ARCH_SUPPORTS_UPROBES=y
CONFIG_UPROBES=y
CONFIG_UPROBE_EVENTS=y
CONFIG_DEBUG_FS=y
# more bpftrace to make that work
CONFIG_IKHEADERS=y
CONFIG_IKCONFIG_PROC=y
CONFIG_IKCONFIG=y
scx-1.0.12/.github/include/update-kernels.py 0000664 0000000 0000000 00000004452 15007705772 0020667 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python3
import argparse
import json
import os
import subprocess
import sys
import time
def get_hash_for_repo_branch(repo, branch):
result = subprocess.run(
["git", "ls-remote", "--exit-code", repo, f"heads/{branch}"],
check=True,
stdout=subprocess.PIPE,
text=True,
)
return result.stdout.split("\t")[0]
def get_nar_hash_and_version(repo, branch, hash):
result = subprocess.run(
["nix", "flake", "prefetch", "--json", f"git+{repo}?ref={branch}&rev={hash}"],
check=True,
stdout=subprocess.PIPE,
text=True,
)
j = json.loads(result.stdout)
result = subprocess.run(
["make", "kernelversion"],
cwd=j["storePath"],
check=True,
stdout=subprocess.PIPE,
text=True,
)
return (j["hash"], result.stdout.rstrip())
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="Update kernel locks")
parser.add_argument(
"versions", nargs="*", help="Named version(s) to update (default=all)"
)
args = parser.parse_args()
try:
with open("kernel-versions.json", "r") as f:
data = json.load(f)
except FileNotFoundError as exc:
raise Exception(
"kernel-versions.json not found. Are you running this script from the root of the scx repo?"
) from exc
diff = False
if args.versions:
versions_set = set(args.versions)
for k, v in data.items():
if args.versions and k not in versions_set:
continue
new_hash = get_hash_for_repo_branch(v["repo"], v["branch"])
old_hash = v.get("commitHash", "")
if new_hash == old_hash:
continue
print(f"Updating {k} from {old_hash} -> {new_hash}")
v["commitHash"] = new_hash
v["lastModified"] = int(time.time())
print(f"Downloading and hashing kernel source for {k}. This will take a while...")
(narHash, kver) = get_nar_hash_and_version(v["repo"], v["branch"], v["commitHash"])
v["narHash"] = narHash
v["kernelVersion"] = kver
diff = True
if not diff:
print("No changes made, exiting.")
sys.exit(0)
content = json.dumps(data, indent=2)
with open("kernel-versions.json", "w") as f:
f.write(content)
scx-1.0.12/.github/workflows/ 0000775 0000000 0000000 00000000000 15007705772 0015777 5 ustar 00root root 0000000 0000000 scx-1.0.12/.github/workflows/6_12.yml 0000664 0000000 0000000 00000001726 15007705772 0017177 0 ustar 00root root 0000000 0000000 name: 6_12-test
on:
# only runs on main, every 6 hours. specify hours explicitly so scheduled runs can be offset and use a random minute.
schedule:
- cron: "46 1,7,13,19 * * *"
jobs:
build-kernel:
uses: ./.github/workflows/build-kernel.yml
with:
repo-name: stable/6_12
integration-test:
uses: ./.github/workflows/integration-tests.yml
needs: build-kernel
with:
repo-name: stable/6_12
notify-job:
runs-on: ubuntu-latest
if: ${{ failure() && github.ref == 'refs/heads/main' }}
needs:
- integration-test
steps:
- uses: actions/checkout@v2
- name: Slack Notification
uses: rtCamp/action-slack-notify@v2
env:
SLACK_USERNAME: ci
SLACK_ICON: https://www.dictionary.com/e/wp-content/uploads/2018/03/thisisfine-1.jpg
SLACK_TITLE: Workflow failed
SLACK_MESSAGE: 6.12 ci job failed.
SLACK_COLOR: failure
SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK_URL }}
scx-1.0.12/.github/workflows/bpf-next-test.yml 0000664 0000000 0000000 00000001741 15007705772 0021225 0 ustar 00root root 0000000 0000000 name: bpf-next-test
on:
# only runs on main, every 6 hours. specify hours explicitly so scheduled runs can be offset and use a random minute.
schedule:
- cron: "35 0,6,12,18 * * *"
jobs:
build-kernel:
uses: ./.github/workflows/build-kernel.yml
with:
repo-name: bpf/bpf-next
integration-test:
uses: ./.github/workflows/integration-tests.yml
needs: build-kernel
with:
repo-name: bpf/bpf-next
notify-job:
runs-on: ubuntu-latest
if: ${{ failure() && github.ref == 'refs/heads/main' }}
needs:
- integration-test
steps:
- uses: actions/checkout@v2
- name: Slack Notification
uses: rtCamp/action-slack-notify@v2
env:
SLACK_USERNAME: ci
SLACK_ICON: https://www.dictionary.com/e/wp-content/uploads/2018/03/thisisfine-1.jpg
SLACK_TITLE: Workflow failed
SLACK_MESSAGE: bpf-next ci job failed.
SLACK_COLOR: failure
SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK_URL }}
scx-1.0.12/.github/workflows/build-kernel.yml 0000664 0000000 0000000 00000004347 15007705772 0021107 0 ustar 00root root 0000000 0000000 on:
workflow_call:
inputs:
repo-name:
required: true
type: string
jobs:
build-kernel:
runs-on: ${{ github.repository_owner == 'sched-ext' && fromJSON('[ "self-hosted", "linux", "x64" ]') || 'ubuntu-latest' }}
steps:
- name: Install Nix
if: ${{ runner.environment == 'github-hosted' }}
uses: DeterminateSystems/nix-installer-action@main
- uses: actions/checkout@v4
- name: Load dependencies
run: nix run ./.github/include#nix-develop-gha -- ./.github/include#restore-kernels
- run: echo "SCHED_EXT_KERNEL_COMMIT=$(jq -r '."${{ inputs.repo-name }}".commitHash' kernel-versions.json)" >> $GITHUB_ENV
# check for cached kernel without downloading
- name: Cache Kernel
id: cache-kernel
uses: actions/cache@v4
with:
path: |
linux/arch/x86/boot/bzImage
linux/usr/include
linux/**/*.h
key: kernel-build-${{ env.SCHED_EXT_KERNEL_COMMIT }}-7
lookup-only: true
- name: Load dependencies
if: ${{ steps.cache-kernel.outputs.cache-hit != 'true' }}
run: nix run ./.github/include#nix-develop-gha -- ./.github/include#build-kernel
- if: ${{ steps.cache-kernel.outputs.cache-hit != 'true' }}
name: Clone Kernel
uses: cytopia/shell-command-retry-action@v0.1.2
with:
retries: 10
pause: 18
command: git clone --single-branch -b $(jq -r '."${{ inputs.repo-name }}".branch' kernel-versions.json) --depth 100 $(jq -r '."${{ inputs.repo-name }}".repo' kernel-versions.json) linux
- if: ${{ steps.cache-kernel.outputs.cache-hit != 'true' }}
name: Select correct commit for cache hash
run: |
cd linux
git switch --detach ${{ env.SCHED_EXT_KERNEL_COMMIT }}
git log -1 --pretty=format:"%h %ad %s" --date=short
- if: ${{ steps.cache-kernel.outputs.cache-hit != 'true' }}
# Build a minimal kernel (with sched-ext enabled) using virtme-ng
run: cd linux && virtme-ng -v --build --config ../.github/include/sched-ext.config
- if: ${{ steps.cache-kernel.outputs.cache-hit != 'true' }}
# Generate kernel headers
run: cd linux && make headers
scx-1.0.12/.github/workflows/caching-build.yml 0000664 0000000 0000000 00000006045 15007705772 0021220 0 ustar 00root root 0000000 0000000 name: build-and-test
on:
push:
pull_request:
merge_group:
jobs:
build-kernel:
uses: ./.github/workflows/build-kernel.yml
with:
repo-name: sched_ext/for-next
rust-tests:
runs-on: ${{ github.repository_owner == 'sched-ext' && fromJSON('[ "self-hosted", "linux", "x64" ]') || 'ubuntu-latest' }}
needs: build-kernel
steps:
- name: Install Nix
if: ${{ runner.environment == 'github-hosted' }}
uses: DeterminateSystems/nix-installer-action@main
- uses: actions/checkout@v4
- name: Load dependencies
run: nix run ./.github/include#nix-develop-gha -- ./.github/include#restore-kernels
- uses: ./.github/actions/restore-kernel-cache
with:
repo-name: sched_ext/for-next
- name: Format
run: nix run ./.github/include#ci -- format
- name: Build
run: nix run ./.github/include#ci -- build
- name: Clippy
run: nix run ./.github/include#ci -- clippy
- name: Test
run: nix run ./.github/include#ci -- test
integration-test:
uses: ./.github/workflows/integration-tests.yml
needs: build-kernel
with:
repo-name: sched_ext/for-next
pages:
runs-on: ubuntu-24.04
if: github.ref == 'refs/heads/main'
permissions:
contents: write # To push a branch
pages: write # To push to a GitHub Pages site
id-token: write # To update the deployment status
steps:
# prevent cache permission errors
- run: sudo chown root /usr/bin/tar && sudo chmod u+s /usr/bin/tar
- uses: actions/checkout@v4
with:
fetch-depth: 0
- uses: ./.github/actions/install-deps-action
- name: Build Book and Linux Docs
run: |
cd / && rustup component add rustfmt && cd $OLDPWD
RUSTDOCFLAGS="--enable-index-page -Zunstable-options" cargo +nightly doc --workspace --no-deps --bins --lib --examples --document-private-items
sudo apt install build-essential graphviz sphinx-doc python3-sphinx-rtd-theme texlive-latex-recommended python3-yaml -y
cargo install htmlq
git clone --single-branch -b for-next --depth 1 https://git.kernel.org/pub/scm/linux/kernel/git/tj/sched_ext.git linux
cd linux
make DOCS_THEME=sphinx_rtd_theme SPHINXDIRS=scheduler htmldocs
make DOCS_THEME=sphinx_rtd_theme SPHINXDIRS=bpf htmldocs
cd ..
cp -a linux/Documentation/output/scheduler target/doc/
cp -a linux/Documentation/output/bpf target/doc/
sed -i 's%server%serverKernel Sched Ext DocsKernel Bpf Helpers Docs%' target/doc/index.html
- name: Setup Pages
uses: actions/configure-pages@v4
- name: Upload artifact
uses: actions/upload-pages-artifact@v3
with:
path: 'target/doc'
- name: Deploy to GitHub Pages
id: deployment
uses: actions/deploy-pages@v4
scx-1.0.12/.github/workflows/integration-tests.yml 0000664 0000000 0000000 00000011345 15007705772 0022211 0 ustar 00root root 0000000 0000000 name: build-and-test
on:
workflow_call:
inputs:
repo-name:
required: true
type: string
jobs:
list-tests:
runs-on: ${{ github.repository_owner == 'sched-ext' && fromJSON('[ "self-hosted", "linux", "x64" ]') || 'ubuntu-latest' }}
outputs:
matrix: ${{ steps.output.outputs.matrix }}
steps:
- name: Install Nix
if: ${{ runner.environment == 'github-hosted' }}
uses: DeterminateSystems/nix-installer-action@main
- uses: actions/checkout@v4
- name: Load dependencies
run: nix run ./.github/include#nix-develop-gha -- ./.github/include#list-tests
- name: List tests
id: output
run: |
python3 - < host-dmesg.ci.log
if: always()
- run: mkdir -p ./log_save/
if: always()
# no symlink following here (to avoid cycle`s)
- run: sudo find '/home/runner/' -iname '*.ci.log' -exec mv {} ./log_save/ \;
if: always()
- name: upload debug logs, bpftrace, veristat, dmesg, etc.
if: always()
uses: actions/upload-artifact@v4
with:
name: ${{ matrix.scheduler['name'] }}${{ matrix.scheduler['flags'] }}_logs_${{ github.run_id }}_${{ github.run_attempt }}
path: ./log_save/*.ci.log
# it's all txt files w/ 90 day retention, lets be nice.
compression-level: 9
scx-1.0.12/.github/workflows/stable.yml 0000664 0000000 0000000 00000001772 15007705772 0020003 0 ustar 00root root 0000000 0000000 name: stable-test
on:
# only runs on main, every 6 hours. specify hours explicitly so scheduled runs can be offset and use a random minute.
schedule:
- cron: "40 2,8,14,20 * * *"
jobs:
build-kernel:
uses: ./.github/workflows/build-kernel.yml
with:
repo-name: stable/linux-rolling-stable
integration-test:
uses: ./.github/workflows/integration-tests.yml
needs: build-kernel
with:
repo-name: stable/linux-rolling-stable
notify-job:
runs-on: ubuntu-latest
if: ${{ failure() && github.ref == 'refs/heads/main' }}
needs:
- integration-test
steps:
- uses: actions/checkout@v2
- name: Slack Notification
uses: rtCamp/action-slack-notify@v2
env:
SLACK_USERNAME: ci
SLACK_ICON: https://www.dictionary.com/e/wp-content/uploads/2018/03/thisisfine-1.jpg
SLACK_TITLE: Workflow failed
SLACK_MESSAGE: stable ci job failed.
SLACK_COLOR: failure
SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK_URL }}
scx-1.0.12/.github/workflows/update-kernels.yml 0000664 0000000 0000000 00000005152 15007705772 0021450 0 ustar 00root root 0000000 0000000 name: update-kernels
on:
workflow_dispatch:
schedule:
- cron: '23 3 * * *'
jobs:
list-kernels:
runs-on: ${{ github.repository_owner == 'sched-ext' && fromJSON('[ "self-hosted", "linux", "x64" ]') || 'ubuntu-latest' }}
outputs:
matrix: ${{ steps.output.outputs.matrix }}
steps:
- name: Install Nix
if: ${{ runner.environment == 'github-hosted' }}
uses: DeterminateSystems/nix-installer-action@main
- uses: actions/checkout@v4
- name: Load dependencies
run: nix run ./.github/include#nix-develop-gha -- ./.github/include#update-kernels
- name: List kernels
id: output
run: |
matrix=$(jq -c 'keys' kernel-versions.json)
echo $matrix
echo "matrix=$matrix" >> $GITHUB_OUTPUT
update-kernels:
runs-on: ${{ github.repository_owner == 'sched-ext' && fromJSON('[ "self-hosted", "linux", "x64" ]') || 'ubuntu-latest' }}
needs: list-kernels
strategy:
matrix:
version: ${{ fromJson(needs.list-kernels.outputs.matrix) }}
steps:
- name: Install Nix
if: ${{ runner.environment == 'github-hosted' }}
uses: DeterminateSystems/nix-installer-action@main
- uses: actions/checkout@v4
with:
token: ${{ secrets.GH_TOKEN_FOR_UPDATES }}
- name: Load dependencies
run: nix run ./.github/include#nix-develop-gha -- ./.github/include#update-kernels
- name: Update kernel
run: |
git switch -c "deps/kernel/${{ matrix.version }}"
nix run ./.github/include#update-kernels -- ${{ matrix.version }}
git diff --exit-code || echo 'modified=true' >> $GITHUB_ENV
- name: Commit and open PR
if: env.modified == 'true'
env:
GH_TOKEN: ${{ secrets.GH_TOKEN_FOR_UPDATES }}
run: |
git config --global user.email "ci-bot@sched-ext.com"
git config --global user.name "sched-ext CI Bot"
git commit -am "chore(deps): update ${{ matrix.version }} kernel"
# we own these branches, force push is fine
git push --force origin "HEAD:deps/kernel/${{ matrix.version }}"
PR_IDS=$(gh pr list --head $(git rev-parse --abbrev-ref HEAD) --json id)
if echo $PR_IDS | jq -e '. == []'; then
gh pr create --fill
else
echo "PR already exists, skipping creation."
fi
gh pr merge --auto
- name: Build Nix kernels
if: env.modified == 'true'
# Non-blocking step to track that these kernels build with Nix
run: nix build ./.github/include#kernels."${{ matrix.version }}"
scx-1.0.12/.gitignore 0000664 0000000 0000000 00000000100 15007705772 0014361 0 ustar 00root root 0000000 0000000 libbpf/
*.gitignore
PKGBUILD
target
*.swp
.cache/
.vscode/
tags
scx-1.0.12/.gitmodules 0000664 0000000 0000000 00000000000 15007705772 0014545 0 ustar 00root root 0000000 0000000 scx-1.0.12/BREAKING_CHANGES.md 0000664 0000000 0000000 00000004413 15007705772 0015240 0 ustar 00root root 0000000 0000000 # Breaking Changes
[sched_ext](https://github.com/sched-ext/scx) is still experimental and while we're trying to reduce the number of breaking changes, sometimes they're neccessary to fix bugs or improve the usability.
Below are the changes in both the sched_ext kernel tree and the associated commits in this repo.
scx: Rename prep_enable() and cancel_enable(), add exit_task() [[Kernel commit](https://github.com/sched-ext/sched_ext/commit/81e1051116ce50b3b9c99ed3de41927cdb981e77) / [PR](https://github.com/sched-ext/sched_ext/pull/100)] [[scx commit](https://github.com/sched-ext/scx/commit/552b75a9c7513cb3635c06a0ade4abdb227d1dc7)]
* `ops.prep_enable()` is now called `ops.init_task()`
* `struct scx_enable_args` is now `struct scx_init_task_args`
* `ops.enable()` and `ops.disable()` are now called when a task enters and exits sched_ext respectively. This is the same for when all tasks are using scx, but the callbacks can now be fired multiple times for tasks switching their sched policy.
* No longer passing struct `scx_enable_args *args` to `ops.enable()`.
* `ops.cancel_enable()` has been removed, and `ops.exit_task()` (explained below) is invoked in its stead.
* `ops.exit_task()` has been added, and is called exactly once when a task is exiting if `ops.init_task()` had been successfully invoked on the task previously (or would have been invoked if the callback was defined).
* Called in lieu of `ops.cancel_enable()` as described above
* Called with `struct scx_exit_task_args *args` instead of `scx_enable_args *args`.
---
scx: Add scx_bpf_select_cpu_dfl() kfunc [[Kernel commit](https://github.com/sched-ext/sched_ext/commit/07acdca60031900f7d2ae824951342e0cd98f74e)…[Kernel commit](https://github.com/sched-ext/sched_ext/commit/fadfa2fb5894723302e579a0edbd17b595572d91), [PR](https://github.com/sched-ext/sched_ext/pull/104)] [[scx commit](https://github.com/sched-ext/scx/commit/552b75a9c7513cb3635c06a0ade4abdb227d1dc7)]
* The default CPU selection logic operates differently now. We no longer pass `SCX_ENQ_LOCAL` when the default CPU selection has found a core to schedule. Callers can instead use `scx_bpf_select_cpu_dfl()` to get the same behavior and then decide whether to direct dispatch or not.
* Tasks can now be direct-dispatched from `ops.select_cpu()`.
scx-1.0.12/Cargo.lock 0000664 0000000 0000000 00000274126 15007705772 0014323 0 ustar 00root root 0000000 0000000 # This file is automatically @generated by Cargo.
# It is not intended for manual editing.
version = 4
[[package]]
name = "addr2line"
version = "0.24.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dfbe277e56a376000877090da837660b4427aad530e3028d44e0bffe4f89a1c1"
dependencies = [
"gimli",
]
[[package]]
name = "adler2"
version = "2.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "512761e0bb2578dd7380c6baaa0f4ce03e84f95e960231d1dec8bf4d7d6e2627"
[[package]]
name = "affinity"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "763e484feceb7dd021b21c5c6f81aee06b1594a743455ec7efbf72e6355e447b"
dependencies = [
"cfg-if",
"errno",
"libc",
"num_cpus",
]
[[package]]
name = "ahash"
version = "0.8.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e89da841a80418a9b391ebaea17f5c112ffaaa96f621d2c285b5174da76b9011"
dependencies = [
"cfg-if",
"once_cell",
"version_check",
"zerocopy",
]
[[package]]
name = "aho-corasick"
version = "1.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
dependencies = [
"memchr",
]
[[package]]
name = "allocator-api2"
version = "0.2.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
[[package]]
name = "android-tzdata"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"
[[package]]
name = "android_system_properties"
version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
dependencies = [
"libc",
]
[[package]]
name = "anstream"
version = "0.6.18"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8acc5369981196006228e28809f761875c0327210a891e941f4c683b3a99529b"
dependencies = [
"anstyle",
"anstyle-parse",
"anstyle-query",
"anstyle-wincon",
"colorchoice",
"is_terminal_polyfill",
"utf8parse",
]
[[package]]
name = "anstyle"
version = "1.0.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "55cc3b69f167a1ef2e161439aa98aed94e6028e5f9a59be9a6ffb47aef1651f9"
[[package]]
name = "anstyle-parse"
version = "0.2.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3b2d16507662817a6a20a9ea92df6652ee4f94f914589377d69f3b21bc5798a9"
dependencies = [
"utf8parse",
]
[[package]]
name = "anstyle-query"
version = "1.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "79947af37f4177cfead1110013d678905c37501914fba0efea834c3fe9a8d60c"
dependencies = [
"windows-sys 0.59.0",
]
[[package]]
name = "anstyle-wincon"
version = "3.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2109dbce0e72be3ec00bed26e6a7479ca384ad226efdd66db8fa2e3a38c83125"
dependencies = [
"anstyle",
"windows-sys 0.59.0",
]
[[package]]
name = "anyhow"
version = "1.0.95"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "34ac096ce696dc2fcabef30516bb13c0a68a11d30131d3df6f04711467681b04"
[[package]]
name = "arraydeque"
version = "0.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7d902e3d592a523def97af8f317b08ce16b7ab854c1985a0c671e6f15cebc236"
[[package]]
name = "arrayvec"
version = "0.7.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
dependencies = [
"serde",
]
[[package]]
name = "async-broadcast"
version = "0.7.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "435a87a52755b8f27fcf321ac4f04b2802e337c8c4872923137471ec39c37532"
dependencies = [
"event-listener",
"event-listener-strategy",
"futures-core",
"pin-project-lite",
]
[[package]]
name = "async-channel"
version = "2.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "89b47800b0be77592da0afd425cc03468052844aff33b84e33cc696f64e77b6a"
dependencies = [
"concurrent-queue",
"event-listener-strategy",
"futures-core",
"pin-project-lite",
]
[[package]]
name = "async-executor"
version = "1.13.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "30ca9a001c1e8ba5149f91a74362376cc6bc5b919d92d988668657bd570bdcec"
dependencies = [
"async-task",
"concurrent-queue",
"fastrand",
"futures-lite",
"slab",
]
[[package]]
name = "async-fs"
version = "2.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ebcd09b382f40fcd159c2d695175b2ae620ffa5f3bd6f664131efff4e8b9e04a"
dependencies = [
"async-lock",
"blocking",
"futures-lite",
]
[[package]]
name = "async-io"
version = "2.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "43a2b323ccce0a1d90b449fd71f2a06ca7faa7c54c2751f06c9bd851fc061059"
dependencies = [
"async-lock",
"cfg-if",
"concurrent-queue",
"futures-io",
"futures-lite",
"parking",
"polling",
"rustix 0.38.43",
"slab",
"tracing",
"windows-sys 0.59.0",
]
[[package]]
name = "async-lock"
version = "3.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ff6e472cdea888a4bd64f342f09b3f50e1886d32afe8df3d663c01140b811b18"
dependencies = [
"event-listener",
"event-listener-strategy",
"pin-project-lite",
]
[[package]]
name = "async-process"
version = "2.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "63255f1dc2381611000436537bbedfe83183faa303a5a0edaf191edef06526bb"
dependencies = [
"async-channel",
"async-io",
"async-lock",
"async-signal",
"async-task",
"blocking",
"cfg-if",
"event-listener",
"futures-lite",
"rustix 0.38.43",
"tracing",
]
[[package]]
name = "async-recursion"
version = "1.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3b43422f69d8ff38f95f1b2bb76517c91589a924d1559a0e935d7c8ce0274c11"
dependencies = [
"proc-macro2",
"quote",
"syn 2.0.95",
]
[[package]]
name = "async-signal"
version = "0.2.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "637e00349800c0bdf8bfc21ebbc0b6524abea702b0da4168ac00d070d0c0b9f3"
dependencies = [
"async-io",
"async-lock",
"atomic-waker",
"cfg-if",
"futures-core",
"futures-io",
"rustix 0.38.43",
"signal-hook-registry",
"slab",
"windows-sys 0.59.0",
]
[[package]]
name = "async-task"
version = "4.7.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de"
[[package]]
name = "async-trait"
version = "0.1.85"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3f934833b4b7233644e5848f235df3f57ed8c80f1528a26c3dfa13d2147fa056"
dependencies = [
"proc-macro2",
"quote",
"syn 2.0.95",
]
[[package]]
name = "atomic-waker"
version = "1.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
[[package]]
name = "autocfg"
version = "1.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
[[package]]
name = "backtrace"
version = "0.3.74"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8d82cb332cdfaed17ae235a638438ac4d4839913cc2af585c3c6746e8f8bee1a"
dependencies = [
"addr2line",
"cfg-if",
"libc",
"miniz_oxide",
"object",
"rustc-demangle",
"windows-targets 0.52.6",
]
[[package]]
name = "base64"
version = "0.21.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
[[package]]
name = "bindgen"
version = "0.63.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "36d860121800b2a9a94f9b5604b332d5cffb234ce17609ea479d723dbc9d3885"
dependencies = [
"bitflags 1.3.2",
"cexpr",
"clang-sys",
"lazy_static",
"lazycell",
"log",
"peeking_take_while",
"proc-macro2",
"quote",
"regex",
"rustc-hash 1.1.0",
"shlex",
"syn 1.0.109",
"which",
]
[[package]]
name = "bindgen"
version = "0.71.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5f58bf3d7db68cfbac37cfc485a8d711e87e064c3d0fe0435b92f7a407f9d6b3"
dependencies = [
"bitflags 2.6.0",
"cexpr",
"clang-sys",
"itertools",
"log",
"prettyplease",
"proc-macro2",
"quote",
"regex",
"rustc-hash 2.1.0",
"shlex",
"syn 2.0.95",
]
[[package]]
name = "bitflags"
version = "1.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
[[package]]
name = "bitflags"
version = "2.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
dependencies = [
"serde",
]
[[package]]
name = "bitvec"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
dependencies = [
"funty",
"radium",
"serde",
"tap",
"wyz",
]
[[package]]
name = "block-buffer"
version = "0.10.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
dependencies = [
"generic-array",
]
[[package]]
name = "blocking"
version = "1.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "703f41c54fc768e63e091340b424302bb1c29ef4aa0c7f10fe849dfb114d29ea"
dependencies = [
"async-channel",
"async-task",
"futures-io",
"futures-lite",
"piper",
]
[[package]]
name = "buddy_system_allocator"
version = "0.11.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a1a0108968a3a2dab95b089c0fc3f1afa7759aa5ebe6f1d86d206d6f7ba726eb"
[[package]]
name = "bumpalo"
version = "3.16.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c"
[[package]]
name = "byteorder"
version = "1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
[[package]]
name = "bytes"
version = "1.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "325918d6fe32f23b19878fe4b34794ae41fc19ddbe53b10571a4874d44ffd39b"
[[package]]
name = "camino"
version = "1.1.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8b96ec4966b5813e2c0507c1f86115c8c5abaadc3980879c3424042a02fd1ad3"
dependencies = [
"serde",
]
[[package]]
name = "cargo-platform"
version = "0.1.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e35af189006b9c0f00a064685c727031e3ed2d8020f7ba284d78cc2671bd36ea"
dependencies = [
"serde",
]
[[package]]
name = "cargo_metadata"
version = "0.15.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "eee4243f1f26fc7a42710e7439c149e2b10b05472f88090acce52632f231a73a"
dependencies = [
"camino",
"cargo-platform",
"semver",
"serde",
"serde_json",
"thiserror 1.0.69",
]
[[package]]
name = "cargo_metadata"
version = "0.18.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2d886547e41f740c616ae73108f6eb70afe6d940c7bc697cb30f13daec073037"
dependencies = [
"camino",
"cargo-platform",
"semver",
"serde",
"serde_json",
"thiserror 1.0.69",
]
[[package]]
name = "cassowary"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "df8670b8c7b9dae1793364eafadf7239c40d669904660c5960d74cfd80b46a53"
[[package]]
name = "castaway"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0abae9be0aaf9ea96a3b1b8b1b55c602ca751eba1b1500220cea4ecbafe7c0d5"
dependencies = [
"rustversion",
]
[[package]]
name = "cc"
version = "1.2.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a012a0df96dd6d06ba9a1b29d6402d1a5d77c6befd2566afdc26e10603dc93d7"
dependencies = [
"shlex",
]
[[package]]
name = "cexpr"
version = "0.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766"
dependencies = [
"nom",
]
[[package]]
name = "cfg-if"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
[[package]]
name = "cfg_aliases"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
[[package]]
name = "cgroupfs"
version = "0.7.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "66348822148cc35473745aaec1dfef694010fc8b437541ef6e64db5c223a0846"
dependencies = [
"nix 0.25.1",
"openat",
"serde",
"thiserror 1.0.69",
]
[[package]]
name = "chrono"
version = "0.4.39"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7e36cc9d416881d2e24f9a963be5fb1cd90966419ac844274161d10488b3e825"
dependencies = [
"android-tzdata",
"iana-time-zone",
"js-sys",
"num-traits",
"wasm-bindgen",
"windows-targets 0.52.6",
]
[[package]]
name = "clang-sys"
version = "1.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0b023947811758c97c59bf9d1c188fd619ad4718dcaa767947df1cadb14f39f4"
dependencies = [
"glob",
"libc",
"libloading",
]
[[package]]
name = "clap"
version = "4.5.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "027bb0d98429ae334a8698531da7077bdf906419543a35a55c2cb1b66437d767"
dependencies = [
"clap_builder",
"clap_derive",
]
[[package]]
name = "clap_builder"
version = "4.5.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5589e0cba072e0f3d23791efac0fd8627b49c829c196a492e88168e6a669d863"
dependencies = [
"anstream",
"anstyle",
"clap_lex",
"strsim 0.11.1",
"terminal_size",
"unicase",
"unicode-width 0.2.0",
]
[[package]]
name = "clap_complete"
version = "4.5.46"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f5c5508ea23c5366f77e53f5a0070e5a84e51687ec3ef9e0464c86dc8d13ce98"
dependencies = [
"clap",
]
[[package]]
name = "clap_derive"
version = "4.5.28"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bf4ced95c6f4a675af3da73304b9ac4ed991640c36374e4b46795c49e17cf1ed"
dependencies = [
"heck",
"proc-macro2",
"quote",
"syn 2.0.95",
]
[[package]]
name = "clap_lex"
version = "0.7.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f46ad14479a25103f283c0f10005961cf086d8dc42205bb44c46ac563475dca6"
[[package]]
name = "colorchoice"
version = "1.0.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5b63caa9aa9397e2d9480a9b13673856c78d8ac123288526c37d7839f2a86990"
[[package]]
name = "colored"
version = "2.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "117725a109d387c937a1533ce01b450cbde6b88abceea8473c4d7a85853cda3c"
dependencies = [
"lazy_static",
"windows-sys 0.59.0",
]
[[package]]
name = "colored"
version = "3.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fde0e0ec90c9dfb3b4b1a0891a7dcd0e2bffde2f7efed5fe7c9bb00e5bfb915e"
dependencies = [
"windows-sys 0.59.0",
]
[[package]]
name = "compact_str"
version = "0.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3b79c4069c6cad78e2e0cdfcbd26275770669fb39fd308a752dc110e83b9af32"
dependencies = [
"castaway",
"cfg-if",
"itoa",
"rustversion",
"ryu",
"serde",
"static_assertions",
]
[[package]]
name = "concurrent-queue"
version = "2.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973"
dependencies = [
"crossbeam-utils",
]
[[package]]
name = "config"
version = "0.14.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "68578f196d2a33ff61b27fae256c3164f65e36382648e30666dde05b8cc9dfdf"
dependencies = [
"async-trait",
"convert_case",
"json5",
"nom",
"pathdiff",
"ron",
"rust-ini",
"serde",
"serde_json",
"toml",
"yaml-rust2",
]
[[package]]
name = "const-random"
version = "0.1.18"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "87e00182fe74b066627d63b85fd550ac2998d4b0bd86bfed477a0ae4c7c71359"
dependencies = [
"const-random-macro",
]
[[package]]
name = "const-random-macro"
version = "0.1.16"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f9d839f2a20b0aee515dc581a6172f2321f96cab76c1a38a4c584a194955390e"
dependencies = [
"getrandom 0.2.15",
"once_cell",
"tiny-keccak",
]
[[package]]
name = "const_format"
version = "0.2.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c990efc7a285731f9a4378d81aff2f0e85a2c8781a05ef0f8baa8dac54d0ff48"
dependencies = [
"const_format_proc_macros",
]
[[package]]
name = "const_format_proc_macros"
version = "0.2.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e026b6ce194a874cb9cf32cd5772d1ef9767cc8fcb5765948d74f37a9d8b2bf6"
dependencies = [
"proc-macro2",
"quote",
"unicode-xid",
]
[[package]]
name = "convert_case"
version = "0.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ec182b0ca2f35d8fc196cf3404988fd8b8c739a4d270ff118a398feb0cbec1ca"
dependencies = [
"unicode-segmentation",
]
[[package]]
name = "core-foundation-sys"
version = "0.8.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
[[package]]
name = "cpufeatures"
version = "0.2.16"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "16b80225097f2e5ae4e7179dd2266824648f3e2f49d9134d584b76389d31c4c3"
dependencies = [
"libc",
]
[[package]]
name = "crossbeam"
version = "0.8.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1137cd7e7fc0fb5d3c5a8678be38ec56e819125d8d7907411fe24ccb943faca8"
dependencies = [
"crossbeam-channel",
"crossbeam-deque",
"crossbeam-epoch",
"crossbeam-queue",
"crossbeam-utils",
]
[[package]]
name = "crossbeam-channel"
version = "0.5.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "06ba6d68e24814cb8de6bb986db8222d3a027d15872cabc0d18817bc3c0e4471"
dependencies = [
"crossbeam-utils",
]
[[package]]
name = "crossbeam-deque"
version = "0.8.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
dependencies = [
"crossbeam-epoch",
"crossbeam-utils",
]
[[package]]
name = "crossbeam-epoch"
version = "0.9.18"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
dependencies = [
"crossbeam-utils",
]
[[package]]
name = "crossbeam-queue"
version = "0.3.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0f58bbc28f91df819d0aa2a2c00cd19754769c2fad90579b3592b1c9ba7a3115"
dependencies = [
"crossbeam-utils",
]
[[package]]
name = "crossbeam-utils"
version = "0.8.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
[[package]]
name = "crossterm"
version = "0.28.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "829d955a0bb380ef178a640b91779e3987da38c9aea133b20614cfed8cdea9c6"
dependencies = [
"bitflags 2.6.0",
"crossterm_winapi",
"futures-core",
"mio",
"parking_lot",
"rustix 0.38.43",
"serde",
"signal-hook",
"signal-hook-mio",
"winapi",
]
[[package]]
name = "crossterm_winapi"
version = "0.9.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "acdd7c62a3665c7f6830a51635d9ac9b23ed385797f70a83bb8bafe9c572ab2b"
dependencies = [
"winapi",
]
[[package]]
name = "crunchy"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
[[package]]
name = "crypto-common"
version = "0.1.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
dependencies = [
"generic-array",
"typenum",
]
[[package]]
name = "ctrlc"
version = "3.4.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "90eeab0aa92f3f9b4e87f258c72b139c207d251f9cbc1080a0086b86a8870dd3"
dependencies = [
"nix 0.29.0",
"windows-sys 0.59.0",
]
[[package]]
name = "darling"
version = "0.20.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6f63b86c8a8826a49b8c21f08a2d07338eec8d900540f8630dc76284be802989"
dependencies = [
"darling_core",
"darling_macro",
]
[[package]]
name = "darling_core"
version = "0.20.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "95133861a8032aaea082871032f5815eb9e98cef03fa916ab4500513994df9e5"
dependencies = [
"fnv",
"ident_case",
"proc-macro2",
"quote",
"strsim 0.11.1",
"syn 2.0.95",
]
[[package]]
name = "darling_macro"
version = "0.20.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d336a2a514f6ccccaa3e09b02d41d35330c07ddf03a62165fcec10bb561c7806"
dependencies = [
"darling_core",
"quote",
"syn 2.0.95",
]
[[package]]
name = "deranged"
version = "0.3.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4"
dependencies = [
"powerfmt",
]
[[package]]
name = "derive_deref"
version = "1.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dcdbcee2d9941369faba772587a565f4f534e42cb8d17e5295871de730163b2b"
dependencies = [
"proc-macro2",
"quote",
"syn 1.0.109",
]
[[package]]
name = "digest"
version = "0.10.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
dependencies = [
"block-buffer",
"crypto-common",
]
[[package]]
name = "directories"
version = "5.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9a49173b84e034382284f27f1af4dcbbd231ffa358c0fe316541a7337f376a35"
dependencies = [
"dirs-sys",
]
[[package]]
name = "dirs-sys"
version = "0.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "520f05a5cbd335fae5a99ff7a6ab8627577660ee5cfd6a94a6a929b52ff0321c"
dependencies = [
"libc",
"option-ext",
"redox_users",
"windows-sys 0.48.0",
]
[[package]]
name = "dlv-list"
version = "0.5.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "442039f5147480ba31067cb00ada1adae6892028e40e45fc5de7b7df6dcc1b5f"
dependencies = [
"const-random",
]
[[package]]
name = "either"
version = "1.13.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0"
[[package]]
name = "encoding_rs"
version = "0.8.35"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3"
dependencies = [
"cfg-if",
]
[[package]]
name = "endi"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a3d8a32ae18130a3c84dd492d4215c3d913c3b07c6b63c2eb3eb7ff1101ab7bf"
[[package]]
name = "enumflags2"
version = "0.7.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d232db7f5956f3f14313dc2f87985c58bd2c695ce124c8cdd984e08e15ac133d"
dependencies = [
"enumflags2_derive",
"serde",
]
[[package]]
name = "enumflags2_derive"
version = "0.7.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "de0d48a183585823424a4ce1aa132d174a6a81bd540895822eb4c8373a8e49e8"
dependencies = [
"proc-macro2",
"quote",
"syn 2.0.95",
]
[[package]]
name = "equivalent"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
[[package]]
name = "errno"
version = "0.3.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "33d852cb9b869c2a9b3df2f71a3074817f01e1844f839a144f5fcef059a4eb5d"
dependencies = [
"libc",
"windows-sys 0.59.0",
]
[[package]]
name = "event-listener"
version = "5.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3492acde4c3fc54c845eaab3eed8bd00c7a7d881f78bfc801e43a93dec1331ae"
dependencies = [
"concurrent-queue",
"parking",
"pin-project-lite",
]
[[package]]
name = "event-listener-strategy"
version = "0.5.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3c3e4e0dd3673c1139bf041f3008816d9cf2946bbfac2945c09e523b8d7b05b2"
dependencies = [
"event-listener",
"pin-project-lite",
]
[[package]]
name = "fastrand"
version = "2.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
[[package]]
name = "fb_procfs"
version = "0.7.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d16e986e12a0b63c17fe7df3569ed524da77d258a900863034571fd08f7553ac"
dependencies = [
"lazy_static",
"libc",
"nix 0.25.1",
"openat",
"serde",
"thiserror 1.0.69",
"threadpool",
]
[[package]]
name = "filetime"
version = "0.2.25"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "35c0522e981e68cbfa8c3f978441a5f34b30b96e146b33cd3359176b50fe8586"
dependencies = [
"cfg-if",
"libc",
"libredox",
"windows-sys 0.59.0",
]
[[package]]
name = "fixedbitset"
version = "0.5.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99"
[[package]]
name = "fnv"
version = "1.0.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
[[package]]
name = "foldhash"
version = "0.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a0d2fde1f7b3d48b8395d5f2de76c18a528bd6a9cdde438df747bfcba3e05d6f"
[[package]]
name = "funty"
version = "2.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
[[package]]
name = "futures"
version = "0.3.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876"
dependencies = [
"futures-channel",
"futures-core",
"futures-executor",
"futures-io",
"futures-sink",
"futures-task",
"futures-util",
]
[[package]]
name = "futures-channel"
version = "0.3.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10"
dependencies = [
"futures-core",
"futures-sink",
]
[[package]]
name = "futures-core"
version = "0.3.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"
[[package]]
name = "futures-executor"
version = "0.3.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f"
dependencies = [
"futures-core",
"futures-task",
"futures-util",
]
[[package]]
name = "futures-io"
version = "0.3.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6"
[[package]]
name = "futures-lite"
version = "2.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f5edaec856126859abb19ed65f39e90fea3a9574b9707f13539acf4abf7eb532"
dependencies = [
"fastrand",
"futures-core",
"futures-io",
"parking",
"pin-project-lite",
]
[[package]]
name = "futures-macro"
version = "0.3.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
dependencies = [
"proc-macro2",
"quote",
"syn 2.0.95",
]
[[package]]
name = "futures-sink"
version = "0.3.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7"
[[package]]
name = "futures-task"
version = "0.3.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988"
[[package]]
name = "futures-util"
version = "0.3.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"
dependencies = [
"futures-channel",
"futures-core",
"futures-io",
"futures-macro",
"futures-sink",
"futures-task",
"memchr",
"pin-project-lite",
"pin-utils",
"slab",
]
[[package]]
name = "generic-array"
version = "0.14.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
dependencies = [
"typenum",
"version_check",
]
[[package]]
name = "getrandom"
version = "0.2.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
dependencies = [
"cfg-if",
"libc",
"wasi 0.11.0+wasi-snapshot-preview1",
]
[[package]]
name = "getrandom"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "73fea8450eea4bac3940448fb7ae50d91f034f941199fcd9d909a5a07aa455f0"
dependencies = [
"cfg-if",
"libc",
"r-efi",
"wasi 0.14.2+wasi-0.2.4",
]
[[package]]
name = "gimli"
version = "0.31.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "07e28edb80900c19c28f1072f2e8aeca7fa06b23cd4169cefe1af5aa3260783f"
[[package]]
name = "glob"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a8d1add55171497b4705a648c6b583acafb01d58050a51727785f0b2c8e0a2b2"
[[package]]
name = "gpoint"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1c00f1d62d57408109a871dd9e12b76645ec4284406d5ec838d277777ef1ef6c"
dependencies = [
"libc",
]
[[package]]
name = "hashbrown"
version = "0.14.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
dependencies = [
"ahash",
"allocator-api2",
]
[[package]]
name = "hashbrown"
version = "0.15.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bf151400ff0baff5465007dd2f3e717f3fe502074ca563069ce3a6629d07b289"
dependencies = [
"allocator-api2",
"equivalent",
"foldhash",
]
[[package]]
name = "hashlink"
version = "0.8.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e8094feaf31ff591f651a2664fb9cfd92bba7a60ce3197265e9482ebe753c8f7"
dependencies = [
"hashbrown 0.14.5",
]
[[package]]
name = "heck"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
[[package]]
name = "hermit-abi"
version = "0.3.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024"
[[package]]
name = "hermit-abi"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fbf6a919d6cf397374f7dfeeea91d974c7c0a7221d0d0f4f20d859d329e53fcc"
[[package]]
name = "hex"
version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
[[package]]
name = "home"
version = "0.5.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "589533453244b0995c858700322199b2becb13b627df2851f64a2775d024abcf"
dependencies = [
"windows-sys 0.59.0",
]
[[package]]
name = "iana-time-zone"
version = "0.1.61"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "235e081f3925a06703c2d0117ea8b91f042756fd6e7a6e5d901e8ca1a996b220"
dependencies = [
"android_system_properties",
"core-foundation-sys",
"iana-time-zone-haiku",
"js-sys",
"wasm-bindgen",
"windows-core 0.52.0",
]
[[package]]
name = "iana-time-zone-haiku"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
dependencies = [
"cc",
]
[[package]]
name = "ident_case"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
[[package]]
name = "indexmap"
version = "2.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "62f822373a4fe84d4bb149bf54e584a7f4abec90e072ed49cda0edea5b95471f"
dependencies = [
"equivalent",
"hashbrown 0.15.2",
]
[[package]]
name = "indoc"
version = "2.0.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b248f5224d1d606005e02c97f5aa4e88eeb230488bcc03bc9ca4d7991399f2b5"
[[package]]
name = "instability"
version = "0.3.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "894813a444908c0c8c0e221b041771d107c4a21de1d317dc49bcc66e3c9e5b3f"
dependencies = [
"darling",
"indoc",
"proc-macro2",
"quote",
"syn 2.0.95",
]
[[package]]
name = "is_terminal_polyfill"
version = "1.70.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf"
[[package]]
name = "itertools"
version = "0.13.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
dependencies = [
"either",
]
[[package]]
name = "itoa"
version = "1.0.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d75a2a4b1b190afb6f5425f10f6a8f959d2ea0b9c2b1d79553551850539e4674"
[[package]]
name = "js-sys"
version = "0.3.76"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6717b6b5b077764fb5966237269cb3c64edddde4b14ce42647430a78ced9e7b7"
dependencies = [
"once_cell",
"wasm-bindgen",
]
[[package]]
name = "json5"
version = "0.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "96b0db21af676c1ce64250b5f40f3ce2cf27e4e47cb91ed91eb6fe9350b430c1"
dependencies = [
"pest",
"pest_derive",
"serde",
]
[[package]]
name = "lazy_static"
version = "1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
[[package]]
name = "lazycell"
version = "1.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
[[package]]
name = "libbpf-cargo"
version = "0.25.0-beta.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d78971d366f266fd02f310b68e8cbf08ebaa35d7dd458ba98360448d8bb25467"
dependencies = [
"anyhow",
"cargo_metadata 0.15.4",
"clap",
"libbpf-rs",
"memmap2",
"regex",
"semver",
"serde",
"serde_json",
"tempfile",
]
[[package]]
name = "libbpf-rs"
version = "0.25.0-beta.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ad0b2c8f481a850c965da7642f3a844c6d32d7f8709b5afb74c5f6bff1e37582"
dependencies = [
"bitflags 2.6.0",
"libbpf-sys",
"libc",
"vsprintf",
]
[[package]]
name = "libbpf-sys"
version = "1.4.6+v1.4.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f30caf02dfece12c94e2835cab8daf7b52e5c62c1675f334f1dac24be5bd5f82"
dependencies = [
"cc",
"nix 0.29.0",
"pkg-config",
]
[[package]]
name = "libc"
version = "0.2.169"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b5aba8db14291edd000dfcc4d620c7ebfb122c613afb886ca8803fa4e128a20a"
[[package]]
name = "libloading"
version = "0.8.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fc2f4eb4bc735547cfed7c0a4922cbd04a4655978c09b54f1f7b228750664c34"
dependencies = [
"cfg-if",
"windows-targets 0.52.6",
]
[[package]]
name = "libredox"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
dependencies = [
"bitflags 2.6.0",
"libc",
"redox_syscall",
]
[[package]]
name = "linux-raw-sys"
version = "0.4.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab"
[[package]]
name = "linux-raw-sys"
version = "0.9.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cd945864f07fe9f5371a27ad7b52a172b4b499999f1d97574c9fa68373937e12"
[[package]]
name = "lock_api"
version = "0.4.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "07af8b9cdd281b7915f413fa73f29ebd5d55d0d3f0155584dade1ff18cea1b17"
dependencies = [
"autocfg",
"scopeguard",
]
[[package]]
name = "log"
version = "0.4.22"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
[[package]]
name = "log-panics"
version = "2.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "68f9dd8546191c1850ecf67d22f5ff00a935b890d0e84713159a55495cc2ac5f"
dependencies = [
"backtrace",
"log",
]
[[package]]
name = "lru"
version = "0.12.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "234cf4f4a04dc1f57e24b96cc0cd600cf2af460d4161ac5ecdd0af8e1f3b2a38"
dependencies = [
"hashbrown 0.15.2",
]
[[package]]
name = "maplit"
version = "1.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3e2e65a1a2e43cfcb47a895c4c8b10d1f4a61097f9f254f183aee60cad9c651d"
[[package]]
name = "matchers"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8263075bb86c5a1b1427b5ae862e8889656f126e9f77c484496e8b47cf5c5558"
dependencies = [
"regex-automata 0.1.10",
]
[[package]]
name = "memchr"
version = "2.7.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
[[package]]
name = "memmap2"
version = "0.5.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "83faa42c0a078c393f6b29d5db232d8be22776a891f8f56e5284faee4a20b327"
dependencies = [
"libc",
]
[[package]]
name = "memoffset"
version = "0.6.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5aa361d4faea93603064a027415f07bd8e1d5c88c9fbf68bf56a285428fd79ce"
dependencies = [
"autocfg",
]
[[package]]
name = "memoffset"
version = "0.9.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
dependencies = [
"autocfg",
]
[[package]]
name = "minimal-lexical"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
[[package]]
name = "miniz_oxide"
version = "0.8.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4ffbe83022cedc1d264172192511ae958937694cd57ce297164951b8b3568394"
dependencies = [
"adler2",
]
[[package]]
name = "mio"
version = "1.0.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2886843bf800fba2e3377cff24abf6379b4c4d5c6681eaf9ea5b0d15090450bd"
dependencies = [
"libc",
"log",
"wasi 0.11.0+wasi-snapshot-preview1",
"windows-sys 0.52.0",
]
[[package]]
name = "multimap"
version = "0.10.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "defc4c55412d89136f966bbb339008b474350e5e6e78d2714439c386b3137a03"
[[package]]
name = "nix"
version = "0.25.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f346ff70e7dbfd675fe90590b92d59ef2de15a8779ae305ebcbfd3f0caf59be4"
dependencies = [
"autocfg",
"bitflags 1.3.2",
"cfg-if",
"libc",
"memoffset 0.6.5",
"pin-utils",
]
[[package]]
name = "nix"
version = "0.29.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "71e2746dc3a24dd78b3cfcb7be93368c6de9963d30f43a6a73998a9cf4b17b46"
dependencies = [
"bitflags 2.6.0",
"cfg-if",
"cfg_aliases",
"libc",
"memoffset 0.9.1",
]
[[package]]
name = "nom"
version = "7.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
dependencies = [
"memchr",
"minimal-lexical",
]
[[package]]
name = "ntapi"
version = "0.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e8a3895c6391c39d7fe7ebc444a87eb2991b2a0bc718fdabd071eec617fc68e4"
dependencies = [
"winapi",
]
[[package]]
name = "nu-ansi-term"
version = "0.46.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "77a8165726e8236064dbb45459242600304b42a5ea24ee2948e18e023bf7ba84"
dependencies = [
"overload",
"winapi",
]
[[package]]
name = "num-conv"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
[[package]]
name = "num-format"
version = "0.4.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a652d9771a63711fd3c3deb670acfbe5c30a4072e664d7a3bf5a9e1056ac72c3"
dependencies = [
"arrayvec",
"cfg-if",
"encoding_rs",
"itoa",
"lazy_static",
"libc",
"num-format-windows",
"serde",
"widestring",
"winapi",
]
[[package]]
name = "num-format-windows"
version = "0.4.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9b1e07f67225c1eb911d16c2f72492669c1fb08212dbfaa1f6cfbeb119152cfa"
dependencies = [
"bindgen 0.63.0",
]
[[package]]
name = "num-traits"
version = "0.2.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
dependencies = [
"autocfg",
]
[[package]]
name = "num_cpus"
version = "1.16.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43"
dependencies = [
"hermit-abi 0.3.9",
"libc",
]
[[package]]
name = "num_threads"
version = "0.1.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5c7398b9c8b70908f6371f47ed36737907c87c52af34c268fed0bf0ceb92ead9"
dependencies = [
"libc",
]
[[package]]
name = "nvml-wrapper"
version = "0.10.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0c9bff0aa1d48904a1385ea2a8b97576fbdcbc9a3cfccd0d31fe978e1c4038c5"
dependencies = [
"bitflags 2.6.0",
"libloading",
"nvml-wrapper-sys",
"static_assertions",
"thiserror 1.0.69",
"wrapcenum-derive",
]
[[package]]
name = "nvml-wrapper-sys"
version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "698d45156f28781a4e79652b6ebe2eaa0589057d588d3aec1333f6466f13fcb5"
dependencies = [
"libloading",
]
[[package]]
name = "object"
version = "0.36.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "62948e14d923ea95ea2c7c86c71013138b66525b86bdc08d2dcc262bdb497b87"
dependencies = [
"memchr",
]
[[package]]
name = "once_cell"
version = "1.20.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1261fe7e33c73b354eab43b1273a57c8f967d0391e80353e51f764ac02cf6775"
[[package]]
name = "openat"
version = "0.1.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "95aa7c05907b3ebde2610d602f4ddd992145cc6a84493647c30396f30ba83abe"
dependencies = [
"libc",
]
[[package]]
name = "option-ext"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
[[package]]
name = "ordered-float"
version = "3.9.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f1e1c390732d15f1d48471625cd92d154e66db2c56645e29a9cd26f4699f72dc"
dependencies = [
"num-traits",
]
[[package]]
name = "ordered-multimap"
version = "0.7.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "49203cdcae0030493bad186b28da2fa25645fa276a51b6fec8010d281e02ef79"
dependencies = [
"dlv-list",
"hashbrown 0.14.5",
]
[[package]]
name = "ordered-stream"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9aa2b01e1d916879f73a53d01d1d6cee68adbb31d6d9177a8cfce093cced1d50"
dependencies = [
"futures-core",
"pin-project-lite",
]
[[package]]
name = "overload"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
[[package]]
name = "parking"
version = "2.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba"
[[package]]
name = "parking_lot"
version = "0.12.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f1bf18183cf54e8d6059647fc3063646a1801cf30896933ec2311622cc4b9a27"
dependencies = [
"lock_api",
"parking_lot_core",
]
[[package]]
name = "parking_lot_core"
version = "0.9.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8"
dependencies = [
"cfg-if",
"libc",
"redox_syscall",
"smallvec",
"windows-targets 0.52.6",
]
[[package]]
name = "paste"
version = "1.0.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
[[package]]
name = "pathdiff"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "df94ce210e5bc13cb6651479fa48d14f601d9858cfe0467f43ae157023b938d3"
[[package]]
name = "peeking_take_while"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "19b17cddbe7ec3f8bc800887bab5e717348c95ea2ca0b1bf0837fb964dc67099"
[[package]]
name = "pest"
version = "2.7.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8b7cafe60d6cf8e62e1b9b2ea516a089c008945bb5a275416789e7db0bc199dc"
dependencies = [
"memchr",
"thiserror 2.0.10",
"ucd-trie",
]
[[package]]
name = "pest_derive"
version = "2.7.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "816518421cfc6887a0d62bf441b6ffb4536fcc926395a69e1a85852d4363f57e"
dependencies = [
"pest",
"pest_generator",
]
[[package]]
name = "pest_generator"
version = "2.7.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7d1396fd3a870fc7838768d171b4616d5c91f6cc25e377b673d714567d99377b"
dependencies = [
"pest",
"pest_meta",
"proc-macro2",
"quote",
"syn 2.0.95",
]
[[package]]
name = "pest_meta"
version = "2.7.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e1e58089ea25d717bfd31fb534e4f3afcc2cc569c70de3e239778991ea3b7dea"
dependencies = [
"once_cell",
"pest",
"sha2",
]
[[package]]
name = "petgraph"
version = "0.7.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3672b37090dbd86368a4145bc067582552b29c27377cad4e0a306c97f9bd7772"
dependencies = [
"fixedbitset",
"indexmap",
]
[[package]]
name = "pin-project-lite"
version = "0.2.16"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
[[package]]
name = "pin-utils"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
[[package]]
name = "piper"
version = "0.2.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "96c8c490f422ef9a4efd2cb5b42b76c8613d7e7dfc1caf667b8a3350a5acc066"
dependencies = [
"atomic-waker",
"fastrand",
"futures-io",
]
[[package]]
name = "pkg-config"
version = "0.3.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "953ec861398dccce10c670dfeaf3ec4911ca479e9c02154b3a215178c5f566f2"
[[package]]
name = "plain"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6"
[[package]]
name = "polling"
version = "3.7.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a604568c3202727d1507653cb121dbd627a58684eb09a820fd746bee38b4442f"
dependencies = [
"cfg-if",
"concurrent-queue",
"hermit-abi 0.4.0",
"pin-project-lite",
"rustix 0.38.43",
"tracing",
"windows-sys 0.59.0",
]
[[package]]
name = "powerfmt"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
[[package]]
name = "ppv-lite86"
version = "0.2.20"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04"
dependencies = [
"zerocopy",
]
[[package]]
name = "prettyplease"
version = "0.2.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "483f8c21f64f3ea09fe0f30f5d48c3e8eefe5dac9129f0075f76593b4c1da705"
dependencies = [
"proc-macro2",
"syn 2.0.95",
]
[[package]]
name = "proc-macro-crate"
version = "3.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8ecf48c7ca261d60b74ab1a7b20da18bede46776b2e55535cb958eb595c5fa7b"
dependencies = [
"toml_edit",
]
[[package]]
name = "proc-macro2"
version = "1.0.92"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "37d3544b3f2748c54e147655edb5025752e2303145b5aefb3c3ea2c78b973bb0"
dependencies = [
"unicode-ident",
]
[[package]]
name = "prost"
version = "0.13.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2796faa41db3ec313a31f7624d9286acf277b52de526150b7e69f3debf891ee5"
dependencies = [
"bytes",
"prost-derive",
]
[[package]]
name = "prost-build"
version = "0.13.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "be769465445e8c1474e9c5dac2018218498557af32d9ed057325ec9a41ae81bf"
dependencies = [
"heck",
"itertools",
"log",
"multimap",
"once_cell",
"petgraph",
"prettyplease",
"prost",
"prost-types",
"regex",
"syn 2.0.95",
"tempfile",
]
[[package]]
name = "prost-derive"
version = "0.13.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8a56d757972c98b346a9b766e3f02746cde6dd1cd1d1d563472929fdd74bec4d"
dependencies = [
"anyhow",
"itertools",
"proc-macro2",
"quote",
"syn 2.0.95",
]
[[package]]
name = "prost-types"
version = "0.13.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "52c2c1bf36ddb1a1c396b3601a3cec27c2462e45f07c386894ec3ccf5332bd16"
dependencies = [
"prost",
]
[[package]]
name = "quote"
version = "1.0.38"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0e4dccaaaf89514f546c693ddc140f729f958c247918a13380cccc6078391acc"
dependencies = [
"proc-macro2",
]
[[package]]
name = "r-efi"
version = "5.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "74765f6d916ee2faa39bc8e68e4f3ed8949b48cccdac59983d287a7cb71ce9c5"
[[package]]
name = "radium"
version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
[[package]]
name = "rand"
version = "0.8.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
dependencies = [
"libc",
"rand_chacha",
"rand_core",
]
[[package]]
name = "rand_chacha"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
dependencies = [
"ppv-lite86",
"rand_core",
]
[[package]]
name = "rand_core"
version = "0.6.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
dependencies = [
"getrandom 0.2.15",
]
[[package]]
name = "ratatui"
version = "0.29.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "eabd94c2f37801c20583fc49dd5cd6b0ba68c716787c2dd6ed18571e1e63117b"
dependencies = [
"bitflags 2.6.0",
"cassowary",
"compact_str",
"crossterm",
"indoc",
"instability",
"itertools",
"lru",
"paste",
"serde",
"strum",
"unicode-segmentation",
"unicode-truncate",
"unicode-width 0.2.0",
]
[[package]]
name = "rayon"
version = "1.10.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa"
dependencies = [
"either",
"rayon-core",
]
[[package]]
name = "rayon-core"
version = "1.12.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2"
dependencies = [
"crossbeam-deque",
"crossbeam-utils",
]
[[package]]
name = "redox_syscall"
version = "0.5.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "03a862b389f93e68874fbf580b9de08dd02facb9a788ebadaf4a3fd33cf58834"
dependencies = [
"bitflags 2.6.0",
]
[[package]]
name = "redox_users"
version = "0.4.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ba009ff324d1fc1b900bd1fdb31564febe58a8ccc8a6fdbb93b543d33b13ca43"
dependencies = [
"getrandom 0.2.15",
"libredox",
"thiserror 1.0.69",
]
[[package]]
name = "regex"
version = "1.11.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
dependencies = [
"aho-corasick",
"memchr",
"regex-automata 0.4.9",
"regex-syntax 0.8.5",
]
[[package]]
name = "regex-automata"
version = "0.1.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"
dependencies = [
"regex-syntax 0.6.29",
]
[[package]]
name = "regex-automata"
version = "0.4.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908"
dependencies = [
"aho-corasick",
"memchr",
"regex-syntax 0.8.5",
]
[[package]]
name = "regex-syntax"
version = "0.6.29"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
[[package]]
name = "regex-syntax"
version = "0.8.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
[[package]]
name = "ron"
version = "0.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b91f7eff05f748767f183df4320a63d6936e9c6107d97c9e6bdd9784f4289c94"
dependencies = [
"base64",
"bitflags 2.6.0",
"serde",
"serde_derive",
]
[[package]]
name = "rust-ini"
version = "0.20.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3e0698206bcb8882bf2a9ecb4c1e7785db57ff052297085a6efd4fe42302068a"
dependencies = [
"cfg-if",
"ordered-multimap",
]
[[package]]
name = "rustc-demangle"
version = "0.1.24"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "719b953e2095829ee67db738b3bfa9fa368c94900df327b3f07fe6e794d2fe1f"
[[package]]
name = "rustc-hash"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
[[package]]
name = "rustc-hash"
version = "2.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c7fb8039b3032c191086b10f11f319a6e99e1e82889c5cc6046f515c9db1d497"
[[package]]
name = "rustix"
version = "0.38.43"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a78891ee6bf2340288408954ac787aa063d8e8817e9f53abb37c695c6d834ef6"
dependencies = [
"bitflags 2.6.0",
"errno",
"libc",
"linux-raw-sys 0.4.15",
"windows-sys 0.59.0",
]
[[package]]
name = "rustix"
version = "1.0.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d97817398dd4bb2e6da002002db259209759911da105da92bec29ccb12cf58bf"
dependencies = [
"bitflags 2.6.0",
"errno",
"libc",
"linux-raw-sys 0.9.4",
"windows-sys 0.59.0",
]
[[package]]
name = "rustversion"
version = "1.0.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f7c45b9784283f1b2e7fb61b42047c2fd678ef0960d4f6f1eba131594cc369d4"
[[package]]
name = "ryu"
version = "1.0.18"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
[[package]]
name = "same-file"
version = "1.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
dependencies = [
"winapi-util",
]
[[package]]
name = "scopeguard"
version = "1.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
[[package]]
name = "scx_bpfland"
version = "1.0.12"
dependencies = [
"anyhow",
"clap",
"crossbeam",
"ctrlc",
"libbpf-rs",
"log",
"scx_stats",
"scx_stats_derive",
"scx_utils",
"serde",
"simplelog",
]
[[package]]
name = "scx_chaos"
version = "1.0.13"
dependencies = [
"anyhow",
"clap",
"ctrlc",
"libbpf-rs",
"libc",
"log",
"nix 0.29.0",
"scx_p2dq",
"scx_userspace_arena",
"scx_utils",
"simplelog",
]
[[package]]
name = "scx_flash"
version = "1.0.10"
dependencies = [
"anyhow",
"clap",
"crossbeam",
"ctrlc",
"libbpf-rs",
"log",
"scx_stats",
"scx_stats_derive",
"scx_utils",
"serde",
"simplelog",
]
[[package]]
name = "scx_lavd"
version = "1.0.12"
dependencies = [
"anyhow",
"bitvec",
"clap",
"crossbeam",
"ctrlc",
"fb_procfs",
"gpoint",
"hex",
"itertools",
"libbpf-rs",
"libc",
"log",
"ordered-float",
"plain",
"scx_stats",
"scx_stats_derive",
"scx_utils",
"serde",
"simplelog",
"static_assertions",
]
[[package]]
name = "scx_layered"
version = "1.0.13"
dependencies = [
"anyhow",
"bitvec",
"chrono",
"clap",
"crossbeam",
"ctrlc",
"fastrand",
"fb_procfs",
"lazy_static",
"libbpf-rs",
"libc",
"log",
"once_cell",
"scx_stats",
"scx_stats_derive",
"scx_utils",
"serde",
"serde_json",
"simplelog",
"walkdir",
]
[[package]]
name = "scx_loader"
version = "1.0.12"
dependencies = [
"anyhow",
"clap",
"colored 3.0.0",
"ctrlc",
"log",
"nix 0.29.0",
"serde",
"sysinfo",
"tokio",
"tokio-util",
"toml",
"zbus",
"zvariant",
]
[[package]]
name = "scx_mitosis"
version = "0.0.9"
dependencies = [
"anyhow",
"bitvec",
"cgroupfs",
"clap",
"ctrlc",
"fb_procfs",
"itertools",
"lazy_static",
"libbpf-rs",
"libc",
"log",
"maplit",
"scx_utils",
"serde",
"serde_json",
"simplelog",
]
[[package]]
name = "scx_p2dq"
version = "1.0.15"
dependencies = [
"anyhow",
"chrono",
"clap",
"crossbeam",
"ctrlc",
"fb_procfs",
"lazy_static",
"libbpf-rs",
"libc",
"log",
"ordered-float",
"scx_stats",
"scx_stats_derive",
"scx_utils",
"serde",
"simplelog",
"sorted-vec",
"static_assertions",
]
[[package]]
name = "scx_rlfifo"
version = "1.0.12"
dependencies = [
"anyhow",
"ctrlc",
"libbpf-rs",
"libc",
"plain",
"scx_rustland_core",
"scx_utils",
]
[[package]]
name = "scx_rustland"
version = "1.0.12"
dependencies = [
"anyhow",
"clap",
"ctrlc",
"fb_procfs",
"libbpf-rs",
"libc",
"log",
"ordered-float",
"plain",
"scx_rustland_core",
"scx_stats",
"scx_stats_derive",
"scx_utils",
"serde",
"simplelog",
]
[[package]]
name = "scx_rustland_core"
version = "2.2.11"
dependencies = [
"anyhow",
"libbpf-rs",
"libc",
"plain",
"scx_utils",
"seccomp",
"tar",
"walkdir",
]
[[package]]
name = "scx_rusty"
version = "1.0.12"
dependencies = [
"anyhow",
"chrono",
"clap",
"crossbeam",
"ctrlc",
"fb_procfs",
"libbpf-rs",
"libc",
"log",
"ordered-float",
"scx_stats",
"scx_stats_derive",
"scx_utils",
"serde",
"simplelog",
"sorted-vec",
"static_assertions",
]
[[package]]
name = "scx_stats"
version = "1.0.12"
dependencies = [
"anyhow",
"crossbeam",
"libc",
"log",
"proc-macro2",
"quote",
"scx_stats_derive",
"serde",
"serde_json",
"simple_logger",
"syn 2.0.95",
]
[[package]]
name = "scx_stats_derive"
version = "1.0.12"
dependencies = [
"proc-macro2",
"quote",
"scx_stats",
"serde_json",
"syn 2.0.95",
]
[[package]]
name = "scx_tickless"
version = "1.0.3"
dependencies = [
"affinity",
"anyhow",
"clap",
"crossbeam",
"ctrlc",
"libbpf-rs",
"log",
"scx_stats",
"scx_stats_derive",
"scx_utils",
"serde",
"simplelog",
]
[[package]]
name = "scx_userspace_arena"
version = "1.0.12"
dependencies = [
"anyhow",
"buddy_system_allocator",
"libbpf-rs",
"scx_utils",
]
[[package]]
name = "scx_utils"
version = "1.0.15"
dependencies = [
"anyhow",
"bindgen 0.71.1",
"bitvec",
"glob",
"hex",
"lazy_static",
"libbpf-cargo",
"libbpf-rs",
"libbpf-sys",
"libc",
"log",
"nvml-wrapper",
"paste",
"regex",
"scx_stats",
"serde",
"sscanf",
"tar",
"tempfile",
"vergen",
"version-compare",
"walkdir",
"zbus",
]
[[package]]
name = "scxctl"
version = "1.0.12"
dependencies = [
"clap",
"colored 3.0.0",
"scx_loader",
"zbus",
]
[[package]]
name = "scxtop"
version = "1.0.13"
dependencies = [
"anyhow",
"clap",
"clap_complete",
"config",
"crossterm",
"derive_deref",
"directories",
"futures",
"glob",
"hashbrown 0.15.2",
"json5",
"lazy_static",
"libbpf-rs",
"libc",
"log",
"log-panics",
"nix 0.29.0",
"num-format",
"plain",
"prost",
"prost-build",
"rand",
"ratatui",
"regex",
"scx_stats",
"scx_utils",
"serde",
"serde_json",
"signal-hook",
"simplelog",
"smartstring",
"strip-ansi-escapes",
"tokio",
"tokio-util",
"toml",
"tracing",
"tracing-error",
"tracing-subscriber",
"xdg",
]
[[package]]
name = "seccomp"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6ca3dd4474d15e6fdaea3c411bfa688c55cd1ae0051391a2b46581fffaed315b"
dependencies = [
"libc",
"seccomp-sys",
]
[[package]]
name = "seccomp-sys"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e5bcf74ba0708aeaf8d702e4f84f7458ae1de42d80e2c20963a395b6038e6be6"
dependencies = [
"libc",
]
[[package]]
name = "semver"
version = "1.0.24"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3cb6eb87a131f756572d7fb904f6e7b68633f09cca868c5df1c4b8d1a694bbba"
dependencies = [
"serde",
]
[[package]]
name = "serde"
version = "1.0.217"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "02fc4265df13d6fa1d00ecff087228cc0a2b5f3c0e87e258d8b94a156e984c70"
dependencies = [
"serde_derive",
]
[[package]]
name = "serde_derive"
version = "1.0.217"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5a9bf7cf98d04a2b28aead066b7496853d4779c9cc183c440dbac457641e19a0"
dependencies = [
"proc-macro2",
"quote",
"syn 2.0.95",
]
[[package]]
name = "serde_json"
version = "1.0.135"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2b0d7ba2887406110130a978386c4e1befb98c674b4fba677954e4db976630d9"
dependencies = [
"itoa",
"memchr",
"ryu",
"serde",
]
[[package]]
name = "serde_repr"
version = "0.1.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6c64451ba24fc7a6a2d60fc75dd9c83c90903b19028d4eff35e88fc1e86564e9"
dependencies = [
"proc-macro2",
"quote",
"syn 2.0.95",
]
[[package]]
name = "serde_spanned"
version = "0.6.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "87607cb1398ed59d48732e575a4c28a7a8ebf2454b964fe3f224f2afc07909e1"
dependencies = [
"serde",
]
[[package]]
name = "sha2"
version = "0.10.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8"
dependencies = [
"cfg-if",
"cpufeatures",
"digest",
]
[[package]]
name = "sharded-slab"
version = "0.1.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6"
dependencies = [
"lazy_static",
]
[[package]]
name = "shlex"
version = "1.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
[[package]]
name = "signal-hook"
version = "0.3.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8621587d4798caf8eb44879d42e56b9a93ea5dcd315a6487c357130095b62801"
dependencies = [
"libc",
"signal-hook-registry",
]
[[package]]
name = "signal-hook-mio"
version = "0.2.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "34db1a06d485c9142248b7a054f034b349b212551f3dfd19c94d45a754a217cd"
dependencies = [
"libc",
"mio",
"signal-hook",
]
[[package]]
name = "signal-hook-registry"
version = "1.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a9e9e0b4211b72e7b8b6e85c807d36c212bdb33ea8587f7569562a84df5465b1"
dependencies = [
"libc",
]
[[package]]
name = "simple_logger"
version = "5.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e8c5dfa5e08767553704aa0ffd9d9794d527103c736aba9854773851fd7497eb"
dependencies = [
"colored 2.2.0",
"log",
"time",
"windows-sys 0.48.0",
]
[[package]]
name = "simplelog"
version = "0.12.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "16257adbfaef1ee58b1363bdc0664c9b8e1e30aed86049635fb5f147d065a9c0"
dependencies = [
"log",
"termcolor",
"time",
]
[[package]]
name = "slab"
version = "0.4.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67"
dependencies = [
"autocfg",
]
[[package]]
name = "smallvec"
version = "1.13.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
[[package]]
name = "smartstring"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3fb72c633efbaa2dd666986505016c32c3044395ceaf881518399d2f4127ee29"
dependencies = [
"autocfg",
"serde",
"static_assertions",
"version_check",
]
[[package]]
name = "socket2"
version = "0.5.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c970269d99b64e60ec3bd6ad27270092a5394c4e309314b18ae3fe575695fbe8"
dependencies = [
"libc",
"windows-sys 0.52.0",
]
[[package]]
name = "sorted-vec"
version = "0.8.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9f64b077cc81ab5f1209bb44c6530a3277261aeaa5405111d48326897306918b"
[[package]]
name = "sscanf"
version = "0.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a147d3cf7e723671ed11355b5b008c8019195f7fc902e213f5557d931e9f839d"
dependencies = [
"const_format",
"lazy_static",
"regex",
"sscanf_macro",
]
[[package]]
name = "sscanf_macro"
version = "0.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "af3a37bdf8e90e77cc60f74473edf28d922ae2eacdd595e67724ccd2381774cc"
dependencies = [
"convert_case",
"proc-macro2",
"quote",
"regex-syntax 0.6.29",
"strsim 0.10.0",
"syn 2.0.95",
"unicode-width 0.1.12",
]
[[package]]
name = "static_assertions"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
[[package]]
name = "strip-ansi-escapes"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "55ff8ef943b384c414f54aefa961dd2bd853add74ec75e7ac74cf91dba62bcfa"
dependencies = [
"vte",
]
[[package]]
name = "strsim"
version = "0.10.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
[[package]]
name = "strsim"
version = "0.11.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
[[package]]
name = "strum"
version = "0.26.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8fec0f0aef304996cf250b31b5a10dee7980c85da9d759361292b8bca5a18f06"
dependencies = [
"strum_macros",
]
[[package]]
name = "strum_macros"
version = "0.26.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4c6bee85a5a24955dc440386795aa378cd9cf82acd5f764469152d2270e581be"
dependencies = [
"heck",
"proc-macro2",
"quote",
"rustversion",
"syn 2.0.95",
]
[[package]]
name = "syn"
version = "1.0.109"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
dependencies = [
"proc-macro2",
"quote",
"unicode-ident",
]
[[package]]
name = "syn"
version = "2.0.95"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "46f71c0377baf4ef1cc3e3402ded576dccc315800fbc62dfc7fe04b009773b4a"
dependencies = [
"proc-macro2",
"quote",
"unicode-ident",
]
[[package]]
name = "sysinfo"
version = "0.33.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4fc858248ea01b66f19d8e8a6d55f41deaf91e9d495246fd01368d99935c6c01"
dependencies = [
"core-foundation-sys",
"libc",
"memchr",
"ntapi",
"rayon",
"windows",
]
[[package]]
name = "tap"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
[[package]]
name = "tar"
version = "0.4.43"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c65998313f8e17d0d553d28f91a0df93e4dbbbf770279c7bc21ca0f09ea1a1f6"
dependencies = [
"filetime",
"libc",
"xattr",
]
[[package]]
name = "tempfile"
version = "3.19.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7437ac7763b9b123ccf33c338a5cc1bac6f69b45a136c19bdd8a65e3916435bf"
dependencies = [
"fastrand",
"getrandom 0.3.2",
"once_cell",
"rustix 1.0.5",
"windows-sys 0.59.0",
]
[[package]]
name = "termcolor"
version = "1.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755"
dependencies = [
"winapi-util",
]
[[package]]
name = "terminal_size"
version = "0.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5352447f921fda68cf61b4101566c0bdb5104eff6804d0678e5227580ab6a4e9"
dependencies = [
"rustix 0.38.43",
"windows-sys 0.59.0",
]
[[package]]
name = "thiserror"
version = "1.0.69"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
dependencies = [
"thiserror-impl 1.0.69",
]
[[package]]
name = "thiserror"
version = "2.0.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a3ac7f54ca534db81081ef1c1e7f6ea8a3ef428d2fc069097c079443d24124d3"
dependencies = [
"thiserror-impl 2.0.10",
]
[[package]]
name = "thiserror-impl"
version = "1.0.69"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
dependencies = [
"proc-macro2",
"quote",
"syn 2.0.95",
]
[[package]]
name = "thiserror-impl"
version = "2.0.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9e9465d30713b56a37ede7185763c3492a91be2f5fa68d958c44e41ab9248beb"
dependencies = [
"proc-macro2",
"quote",
"syn 2.0.95",
]
[[package]]
name = "thread_local"
version = "1.1.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8b9ef9bad013ada3808854ceac7b46812a6465ba368859a37e2100283d2d719c"
dependencies = [
"cfg-if",
"once_cell",
]
[[package]]
name = "threadpool"
version = "1.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d050e60b33d41c19108b32cea32164033a9013fe3b46cbd4457559bfbf77afaa"
dependencies = [
"num_cpus",
]
[[package]]
name = "time"
version = "0.3.37"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "35e7868883861bd0e56d9ac6efcaaca0d6d5d82a2a7ec8209ff492c07cf37b21"
dependencies = [
"deranged",
"itoa",
"libc",
"num-conv",
"num_threads",
"powerfmt",
"serde",
"time-core",
"time-macros",
]
[[package]]
name = "time-core"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3"
[[package]]
name = "time-macros"
version = "0.2.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2834e6017e3e5e4b9834939793b282bc03b37a3336245fa820e35e233e2a85de"
dependencies = [
"num-conv",
"time-core",
]
[[package]]
name = "tiny-keccak"
version = "2.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237"
dependencies = [
"crunchy",
]
[[package]]
name = "tokio"
version = "1.43.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3d61fa4ffa3de412bfea335c6ecff681de2b609ba3c77ef3e00e521813a9ed9e"
dependencies = [
"backtrace",
"bytes",
"libc",
"mio",
"parking_lot",
"pin-project-lite",
"signal-hook-registry",
"socket2",
"tokio-macros",
"tracing",
"windows-sys 0.52.0",
]
[[package]]
name = "tokio-macros"
version = "2.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6e06d43f1345a3bcd39f6a56dbb7dcab2ba47e68e8ac134855e7e2bdbaf8cab8"
dependencies = [
"proc-macro2",
"quote",
"syn 2.0.95",
]
[[package]]
name = "tokio-util"
version = "0.7.13"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d7fcaa8d55a2bdd6b83ace262b016eca0d79ee02818c5c1bcdf0305114081078"
dependencies = [
"bytes",
"futures-core",
"futures-sink",
"pin-project-lite",
"tokio",
]
[[package]]
name = "toml"
version = "0.8.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a1ed1f98e3fdc28d6d910e6737ae6ab1a93bf1985935a1193e68f93eeb68d24e"
dependencies = [
"serde",
"serde_spanned",
"toml_datetime",
"toml_edit",
]
[[package]]
name = "toml_datetime"
version = "0.6.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0dd7358ecb8fc2f8d014bf86f6f638ce72ba252a2c3a2572f2a795f1d23efb41"
dependencies = [
"serde",
]
[[package]]
name = "toml_edit"
version = "0.22.22"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4ae48d6208a266e853d946088ed816055e556cc6028c5e8e2b84d9fa5dd7c7f5"
dependencies = [
"indexmap",
"serde",
"serde_spanned",
"toml_datetime",
"winnow 0.6.22",
]
[[package]]
name = "tracing"
version = "0.1.41"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "784e0ac535deb450455cbfa28a6f0df145ea1bb7ae51b821cf5e7927fdcfbdd0"
dependencies = [
"pin-project-lite",
"tracing-attributes",
"tracing-core",
]
[[package]]
name = "tracing-attributes"
version = "0.1.28"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "395ae124c09f9e6918a2310af6038fba074bcf474ac352496d5910dd59a2226d"
dependencies = [
"proc-macro2",
"quote",
"syn 2.0.95",
]
[[package]]
name = "tracing-core"
version = "0.1.33"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e672c95779cf947c5311f83787af4fa8fffd12fb27e4993211a84bdfd9610f9c"
dependencies = [
"once_cell",
"valuable",
]
[[package]]
name = "tracing-error"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8b1581020d7a273442f5b45074a6a57d5757ad0a47dac0e9f0bd57b81936f3db"
dependencies = [
"tracing",
"tracing-subscriber",
]
[[package]]
name = "tracing-log"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3"
dependencies = [
"log",
"once_cell",
"tracing-core",
]
[[package]]
name = "tracing-subscriber"
version = "0.3.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e8189decb5ac0fa7bc8b96b7cb9b2701d60d48805aca84a238004d665fcc4008"
dependencies = [
"matchers",
"nu-ansi-term",
"once_cell",
"regex",
"serde",
"sharded-slab",
"smallvec",
"thread_local",
"tracing",
"tracing-core",
"tracing-log",
]
[[package]]
name = "typenum"
version = "1.17.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
[[package]]
name = "ucd-trie"
version = "0.1.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2896d95c02a80c6d6a5d6e953d479f5ddf2dfdb6a244441010e373ac0fb88971"
[[package]]
name = "uds_windows"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "89daebc3e6fd160ac4aa9fc8b3bf71e1f74fbf92367ae71fb83a037e8bf164b9"
dependencies = [
"memoffset 0.9.1",
"tempfile",
"winapi",
]
[[package]]
name = "unicase"
version = "2.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "75b844d17643ee918803943289730bec8aac480150456169e647ed0b576ba539"
[[package]]
name = "unicode-ident"
version = "1.0.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "adb9e6ca4f869e1180728b7950e35922a7fc6397f7b641499e8f3ef06e50dc83"
[[package]]
name = "unicode-segmentation"
version = "1.12.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493"
[[package]]
name = "unicode-truncate"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b3644627a5af5fa321c95b9b235a72fd24cd29c648c2c379431e6628655627bf"
dependencies = [
"itertools",
"unicode-segmentation",
"unicode-width 0.1.12",
]
[[package]]
name = "unicode-width"
version = "0.1.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "68f5e5f3158ecfd4b8ff6fe086db7c8467a2dfdac97fe420f2b7c4aa97af66d6"
[[package]]
name = "unicode-width"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1fc81956842c57dac11422a97c3b8195a1ff727f06e85c84ed2e8aa277c9a0fd"
[[package]]
name = "unicode-xid"
version = "0.2.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
[[package]]
name = "utf8parse"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
[[package]]
name = "valuable"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d"
[[package]]
name = "vergen"
version = "8.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2990d9ea5967266ea0ccf413a4aa5c42a93dbcfda9cb49a97de6931726b12566"
dependencies = [
"anyhow",
"cargo_metadata 0.18.1",
"cfg-if",
"regex",
"rustversion",
"time",
]
[[package]]
name = "version-compare"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "579a42fc0b8e0c63b76519a339be31bed574929511fa53c1a3acae26eb258f29"
[[package]]
name = "version_check"
version = "0.9.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
[[package]]
name = "vmlinux_docify"
version = "0.1.1"
dependencies = [
"clap",
"walkdir",
]
[[package]]
name = "vsprintf"
version = "2.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "aec2f81b75ca063294776b4f7e8da71d1d5ae81c2b1b149c8d89969230265d63"
dependencies = [
"cc",
"libc",
]
[[package]]
name = "vte"
version = "0.11.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f5022b5fbf9407086c180e9557be968742d839e68346af7792b8592489732197"
dependencies = [
"utf8parse",
"vte_generate_state_changes",
]
[[package]]
name = "vte_generate_state_changes"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2e369bee1b05d510a7b4ed645f5faa90619e05437111783ea5848f28d97d3c2e"
dependencies = [
"proc-macro2",
"quote",
]
[[package]]
name = "walkdir"
version = "2.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
dependencies = [
"same-file",
"winapi-util",
]
[[package]]
name = "wasi"
version = "0.11.0+wasi-snapshot-preview1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
[[package]]
name = "wasi"
version = "0.14.2+wasi-0.2.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9683f9a5a998d873c0d21fcbe3c083009670149a8fab228644b8bd36b2c48cb3"
dependencies = [
"wit-bindgen-rt",
]
[[package]]
name = "wasm-bindgen"
version = "0.2.99"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a474f6281d1d70c17ae7aa6a613c87fce69a127e2624002df63dcb39d6cf6396"
dependencies = [
"cfg-if",
"once_cell",
"wasm-bindgen-macro",
]
[[package]]
name = "wasm-bindgen-backend"
version = "0.2.99"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5f89bb38646b4f81674e8f5c3fb81b562be1fd936d84320f3264486418519c79"
dependencies = [
"bumpalo",
"log",
"proc-macro2",
"quote",
"syn 2.0.95",
"wasm-bindgen-shared",
]
[[package]]
name = "wasm-bindgen-macro"
version = "0.2.99"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2cc6181fd9a7492eef6fef1f33961e3695e4579b9872a6f7c83aee556666d4fe"
dependencies = [
"quote",
"wasm-bindgen-macro-support",
]
[[package]]
name = "wasm-bindgen-macro-support"
version = "0.2.99"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "30d7a95b763d3c45903ed6c81f156801839e5ee968bb07e534c44df0fcd330c2"
dependencies = [
"proc-macro2",
"quote",
"syn 2.0.95",
"wasm-bindgen-backend",
"wasm-bindgen-shared",
]
[[package]]
name = "wasm-bindgen-shared"
version = "0.2.99"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "943aab3fdaaa029a6e0271b35ea10b72b943135afe9bffca82384098ad0e06a6"
[[package]]
name = "which"
version = "4.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "87ba24419a2078cd2b0f2ede2691b6c66d8e47836da3b6db8265ebad47afbfc7"
dependencies = [
"either",
"home",
"once_cell",
"rustix 0.38.43",
]
[[package]]
name = "widestring"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7219d36b6eac893fa81e84ebe06485e7dcbb616177469b142df14f1f4deb1311"
[[package]]
name = "winapi"
version = "0.3.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
dependencies = [
"winapi-i686-pc-windows-gnu",
"winapi-x86_64-pc-windows-gnu",
]
[[package]]
name = "winapi-i686-pc-windows-gnu"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
[[package]]
name = "winapi-util"
version = "0.1.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
dependencies = [
"windows-sys 0.59.0",
]
[[package]]
name = "winapi-x86_64-pc-windows-gnu"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
[[package]]
name = "windows"
version = "0.57.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "12342cb4d8e3b046f3d80effd474a7a02447231330ef77d71daa6fbc40681143"
dependencies = [
"windows-core 0.57.0",
"windows-targets 0.52.6",
]
[[package]]
name = "windows-core"
version = "0.52.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
dependencies = [
"windows-targets 0.52.6",
]
[[package]]
name = "windows-core"
version = "0.57.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d2ed2439a290666cd67ecce2b0ffaad89c2a56b976b736e6ece670297897832d"
dependencies = [
"windows-implement",
"windows-interface",
"windows-result",
"windows-targets 0.52.6",
]
[[package]]
name = "windows-implement"
version = "0.57.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9107ddc059d5b6fbfbffdfa7a7fe3e22a226def0b2608f72e9d552763d3e1ad7"
dependencies = [
"proc-macro2",
"quote",
"syn 2.0.95",
]
[[package]]
name = "windows-interface"
version = "0.57.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "29bee4b38ea3cde66011baa44dba677c432a78593e202392d1e9070cf2a7fca7"
dependencies = [
"proc-macro2",
"quote",
"syn 2.0.95",
]
[[package]]
name = "windows-result"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5e383302e8ec8515204254685643de10811af0ed97ea37210dc26fb0032647f8"
dependencies = [
"windows-targets 0.52.6",
]
[[package]]
name = "windows-sys"
version = "0.48.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
dependencies = [
"windows-targets 0.48.5",
]
[[package]]
name = "windows-sys"
version = "0.52.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
dependencies = [
"windows-targets 0.52.6",
]
[[package]]
name = "windows-sys"
version = "0.59.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
dependencies = [
"windows-targets 0.52.6",
]
[[package]]
name = "windows-targets"
version = "0.48.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
dependencies = [
"windows_aarch64_gnullvm 0.48.5",
"windows_aarch64_msvc 0.48.5",
"windows_i686_gnu 0.48.5",
"windows_i686_msvc 0.48.5",
"windows_x86_64_gnu 0.48.5",
"windows_x86_64_gnullvm 0.48.5",
"windows_x86_64_msvc 0.48.5",
]
[[package]]
name = "windows-targets"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
dependencies = [
"windows_aarch64_gnullvm 0.52.6",
"windows_aarch64_msvc 0.52.6",
"windows_i686_gnu 0.52.6",
"windows_i686_gnullvm",
"windows_i686_msvc 0.52.6",
"windows_x86_64_gnu 0.52.6",
"windows_x86_64_gnullvm 0.52.6",
"windows_x86_64_msvc 0.52.6",
]
[[package]]
name = "windows_aarch64_gnullvm"
version = "0.48.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
[[package]]
name = "windows_aarch64_gnullvm"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
[[package]]
name = "windows_aarch64_msvc"
version = "0.48.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
[[package]]
name = "windows_aarch64_msvc"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
[[package]]
name = "windows_i686_gnu"
version = "0.48.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
[[package]]
name = "windows_i686_gnu"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
[[package]]
name = "windows_i686_gnullvm"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
[[package]]
name = "windows_i686_msvc"
version = "0.48.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
[[package]]
name = "windows_i686_msvc"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
[[package]]
name = "windows_x86_64_gnu"
version = "0.48.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
[[package]]
name = "windows_x86_64_gnu"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
[[package]]
name = "windows_x86_64_gnullvm"
version = "0.48.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
[[package]]
name = "windows_x86_64_gnullvm"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
[[package]]
name = "windows_x86_64_msvc"
version = "0.48.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
[[package]]
name = "windows_x86_64_msvc"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
[[package]]
name = "winnow"
version = "0.6.22"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "39281189af81c07ec09db316b302a3e67bf9bd7cbf6c820b50e35fee9c2fa980"
dependencies = [
"memchr",
]
[[package]]
name = "winnow"
version = "0.7.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0e7f4ea97f6f78012141bcdb6a216b2609f0979ada50b20ca5b52dde2eac2bb1"
dependencies = [
"memchr",
]
[[package]]
name = "wit-bindgen-rt"
version = "0.39.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1"
dependencies = [
"bitflags 2.6.0",
]
[[package]]
name = "wrapcenum-derive"
version = "0.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a76ff259533532054cfbaefb115c613203c73707017459206380f03b3b3f266e"
dependencies = [
"darling",
"proc-macro2",
"quote",
"syn 2.0.95",
]
[[package]]
name = "wyz"
version = "0.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
dependencies = [
"tap",
]
[[package]]
name = "xattr"
version = "1.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e105d177a3871454f754b33bb0ee637ecaaac997446375fd3e5d43a2ed00c909"
dependencies = [
"libc",
"linux-raw-sys 0.4.15",
"rustix 0.38.43",
]
[[package]]
name = "xdg"
version = "2.5.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "213b7324336b53d2414b2db8537e56544d981803139155afa84f76eeebb7a546"
[[package]]
name = "xdg-home"
version = "1.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ec1cdab258fb55c0da61328dc52c8764709b249011b2cad0454c72f0bf10a1f6"
dependencies = [
"libc",
"windows-sys 0.59.0",
]
[[package]]
name = "yaml-rust2"
version = "0.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8902160c4e6f2fb145dbe9d6760a75e3c9522d8bf796ed7047c85919ac7115f8"
dependencies = [
"arraydeque",
"encoding_rs",
"hashlink",
]
[[package]]
name = "zbus"
version = "5.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "59c333f648ea1b647bc95dc1d34807c8e25ed7a6feff3394034dc4776054b236"
dependencies = [
"async-broadcast",
"async-executor",
"async-fs",
"async-io",
"async-lock",
"async-process",
"async-recursion",
"async-task",
"async-trait",
"blocking",
"enumflags2",
"event-listener",
"futures-core",
"futures-lite",
"hex",
"nix 0.29.0",
"ordered-stream",
"serde",
"serde_repr",
"static_assertions",
"tokio",
"tracing",
"uds_windows",
"windows-sys 0.59.0",
"winnow 0.7.3",
"xdg-home",
"zbus_macros",
"zbus_names",
"zvariant",
]
[[package]]
name = "zbus_macros"
version = "5.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f325ad10eb0d0a3eb060203494c3b7ec3162a01a59db75d2deee100339709fc0"
dependencies = [
"proc-macro-crate",
"proc-macro2",
"quote",
"syn 2.0.95",
"zbus_names",
"zvariant",
"zvariant_utils",
]
[[package]]
name = "zbus_names"
version = "4.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "856b7a38811f71846fd47856ceee8bccaec8399ff53fb370247e66081ace647b"
dependencies = [
"serde",
"static_assertions",
"winnow 0.6.22",
"zvariant",
]
[[package]]
name = "zerocopy"
version = "0.7.35"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
dependencies = [
"byteorder",
"zerocopy-derive",
]
[[package]]
name = "zerocopy-derive"
version = "0.7.35"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
dependencies = [
"proc-macro2",
"quote",
"syn 2.0.95",
]
[[package]]
name = "zvariant"
version = "5.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a1200ee6ac32f1e5a312e455a949a4794855515d34f9909f4a3e082d14e1a56f"
dependencies = [
"endi",
"enumflags2",
"serde",
"static_assertions",
"winnow 0.6.22",
"zvariant_derive",
"zvariant_utils",
]
[[package]]
name = "zvariant_derive"
version = "5.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "687e3b97fae6c9104fbbd36c73d27d149abf04fb874e2efbd84838763daa8916"
dependencies = [
"proc-macro-crate",
"proc-macro2",
"quote",
"syn 2.0.95",
"zvariant_utils",
]
[[package]]
name = "zvariant_utils"
version = "3.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e16edfee43e5d7b553b77872d99bc36afdda75c223ca7ad5e3fbecd82ca5fc34"
dependencies = [
"proc-macro2",
"quote",
"serde",
"static_assertions",
"syn 2.0.95",
"winnow 0.7.3",
]
scx-1.0.12/Cargo.toml 0000664 0000000 0000000 00000001375 15007705772 0014340 0 ustar 00root root 0000000 0000000 [workspace]
members = [
"rust/scx_loader",
"rust/scx_rustland_core",
"rust/scx_stats",
"rust/scx_stats/scx_stats_derive",
"rust/scx_userspace_arena",
"rust/scx_utils",
"scheds/rust/scx_bpfland",
"scheds/rust/scx_chaos",
"scheds/rust/scx_flash",
"scheds/rust/scx_lavd",
"scheds/rust/scx_layered",
"scheds/rust/scx_mitosis",
"scheds/rust/scx_p2dq",
"scheds/rust/scx_rlfifo",
"scheds/rust/scx_rustland",
"scheds/rust/scx_rusty",
"scheds/rust/scx_tickless",
"tools/scxctl",
"tools/scxtop",
"tools/vmlinux_docify",
]
resolver = "2"
[profile.release]
lto = "thin"
[profile.release-fast]
inherits = "release"
target-cpu = "native"
lto = false
incremental = true
opt-level = 0
debuginfo = 0
scx-1.0.12/DEVELOPER_GUIDE.md 0000664 0000000 0000000 00000034173 15007705772 0015176 0 ustar 00root root 0000000 0000000 # Developer Guide
## eBPF
The scheduling logic for sched_ext schedulers is written in eBPF (BPF). For
high level documentation the kernel docs should be referenced.
- [kernel documentation](https://docs.kernel.org/bpf/index.html)
- [eBPF docs](https://ebpf-docs.dylanreimerink.nl/)
- [rustdocs and sched_ext for-next docs](https://sched-ext.github.io/scx/)
When working on schedulers the following documentation is rather useful as
schedulers will use a combination of BPF cpumasks, helper functions, kfuncs and
maps for scheduling logic.
- [BPF maps](https://docs.kernel.org/bpf/maps.html)
- [bpf helper functions](https://man7.org/linux/man-pages/man7/bpf-helpers.7.html)
- [kfuncs](https://docs.kernel.org/bpf/kfuncs.html)
- [BPF cpumasks](https://docs.kernel.org/bpf/cpumasks.html)
The [kernel BPF tests](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/tools/testing/selftests/bpf)
are also a useful source of examples of BPF functionality.
## Scheduling
The [kernel scheduling docs](https://docs.kernel.org/scheduler/index.html)
provide a high level overview of the existing scheduler subsystem. The kernel
docs cover various topics such as deadline scheduling, realtime scheduling and
the interaction of schedulers with other system resources.
When schedulers are written to scale beyond more than a single core eventually
the scheduler needs to implement a load balancing algorithm. Calculating the
load between scheduling domains becomes a difficult problem. sched_ext has a
common crate for calculating weights between scheduling domains. See the
`infeasible` crate in `rust/scx_utils/src` for the implementation.
## Development kernels
This repository has a kernel lock file at `./kernel-versions.json` where we track
several kernels important to development.
If your change requires a new commit from a branch, you can update this file with:
nix run ./.github/include#update-kernels
or with:
python3 ./.github/include/update-kernels.py
Otherwise new changes will be picked up automatically. If the changes that are
picked up automatically fail CI, you can fix this in a PR separately - the automatic
updater will kick back in once things are green. Create a branch and PR as normal
both updating the kernel lock and making necessary fixes to the codebase.
We use `virtme-ng` for testing in the CI environment, and it should be possible
to reproduce this locally with the same pinned kernels. Currently the most effective
documentation for this will be to read the CI workflows. If this improves in the
future we'll endeavour to update this documentation.
## Rust
We use `cargo fmt` to ensure consistency in our Rust code. This runs on PRs in
the CI and will fail with a patch if your code doesn't match. We currently need
a nightly version of Rust to format so have pinned this for consistency. If you
have rustup installed this will use the version in `rust-toolchain.toml`.
$ cargo fmt
## Useful Tools
## [scxtop](https://github.com/sched-ext/scx/blob/main/tools/scxtop/README.md)
`scxtop` is a top like tool that collects and aggregates various perf and
sched_ext events. See the
[README](https://github.com/sched-ext/scx/blob/main/tools/scxtop/README.md) for
more details.
### [Perfetto](https://perfetto.dev/)
[Perfetto](https://perfetto.dev/) is a profiling and trace visualization
platform. It can be used to view scheduling data, which is useful for
understanding scheduling decisions. The [`sched_ftrace.py`](scripts/sched_ftrace.py)
script can be used to generate a ftrace compatible with Perfetto.
```
$ sudo ./scripts/sched_ftrace.py > sched.ftrace
```
The output of the script can then be loaded into the perfetto UI:
### perf
The linux `perf` tool has a subcommand for profiling scheduling `perf sched`.
The interface is text driven, but is able to provide various timeline views and
aggregations of scheduler events. The following is an example of using `perf
sched` to get a timeline histogram with additional scheduling metrics.
```
$ perf sched record
$ perf sched timehist -Vw --state
time cpu 0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0 task name wait time sch delay run time state
[tid/pid] (msec) (msec) (msec)
--------------- ------ --------------------------------------------------------------------------------- ------------------------------ --------- --------- --------- -----
960264.500659 [0000] perf[1635250] awakened: migration/0[19]
960264.500680 [0000] s perf[1635250] 0.000 0.000 0.000 D
960264.500683 [0000] migration/0[19] awakened: perf[1635250]
960264.500809 [0001] perf[1635250] awakened: migration/1[24]
960264.500814 [0001] s perf[1635250] 0.000 0.000 0.000 D
960264.500816 [0001] migration/1[24] awakened: perf[1635250]
960264.500824 [0001] s migration/1[24] 0.000 0.005 0.009 S
960264.502403 [0001] i 0.000 0.000 1.579 I
960264.502418 [0001] s HTTPSrvExec39[3403538/3403436] 0.000 0.000 0.014 S
960264.506002 [0001] i 0.014 0.000 3.583 I
960264.506045 [0001] s CfgrIO0[13302/13094] 0.000 0.000 0.043 S
960264.506763 [0001] swapper awakened: chef-client[1629157]
960264.506767 [0001] i 0.043 0.000 0.721 I
960264.506784 [0001] s chef-client[1629157] 0.000 0.003 0.017 S
960264.507622 [0001] i 0.017 0.000 0.837 I
960264.507806 [0001] mcrcfg-fci[1635235/1635080] awakened: GlobalCPUThread[1635186/1635080
960264.507937 [0001] mcrcfg-fci[1635235/1635080] awakened: FalconClientThr[1635187/1635080
960264.507996 [0001] mcrcfg-fci[1635235/1635080] awakened: CfgrIO0[1635185/1635080]
960264.508007 [0001] s mcrcfg-fci[1635235/1635080] 0.000 0.000 0.384 S
960264.508079 [0001] i 0.384 0.000 0.071 I
960264.508100 [0001] ThriftSrv.N2104[1635036/2683498 awakened: IOThreadPool0[2685229/2683498]
960264.508108 [0001] s ThriftSrv.N2104[1635036/2683498 0.000 0.000 0.029 S
960264.508638 [0001] i 0.029 0.000 0.529 I
960264.508655 [0001] ThriftSrv.N2104[1635036/2683498 awakened: ThriftIO70[2683693/2683498]
```
### `bpftool`
[`bpftool`](https://github.com/libbpf/bpftool) contains many utilities for
interacting with the BPF subsystem and BPF programs. If you need to know
what BPF programs, maps, iterators are loaded on a system `bpftool` will
provide all this information.
Listing BPF maps:
```
$ sudo bpftool map list
11: hash_of_maps name cgroup_hash flags 0x0
key 8B value 4B max_entries 2048 memlock 172992B
pids systemd(1)
```
Listing `struct_ops`:
```
$ sudo bpftool struct_ops list
21381: layered sched_ext_ops
```
### `retsnoop`
[`retsnoop`](https://github.com/anakryiko/retsnoop) is a BPF tool for tracing
linux. It is very useful if you are trying to understand the flow of kernel
functions. This can be useful when BPF verification issues are encountered. The
following example shows how the verifier `do_check_common` function can be
traced.
```
$ sudo retsnoop -e 'do_check*' -a ':kernel/bpf/*.c' -T
07:55:28.049718 -> 07:55:28.049797 TID/PID 270611/270611 (bpftool/bpftool):
FUNCTION CALL TRACE RESULT DURATION
--------------------------------- --------- --------
→ do_check_common
→ init_func_state
↔ tnum_const [0] 2.084us
← init_func_state [void] 6.648us
↔ tnum_const [0] 2.662us
→ do_check
↔ mark_reg_unknown [void] 2.251us
↔ tnum_const [0] 2.421us
↔ reg_bounds_sanity_check [0] 2.049us
↔ check_reference_leak [0] 2.014us
→ check_return_code
↔ mark_reg_read [0] 2.212us
← check_return_code [0] 6.531us
↔ pop_stack [-ENOENT] 2.099us
← do_check [0] 34.822us
↔ pop_stack [-ENOENT] 2.167us
← do_check_common [0] 76.413us
entry_SYSCALL_64_after_hwframe+0x4b (entry_SYSCALL_64 @ arch/x86/entry/entry_64.S:130:0)
do_syscall_64+0x6a (arch/x86/entry/common.c:0:0)
__x64_sys_bpf+0x18 (kernel/bpf/syscall.c:5792:1)
. __se_sys_bpf (kernel/bpf/syscall.c:5792:1)
. __do_sys_bpf (kernel/bpf/syscall.c:5794:9)
__sys_bpf+0x27e (kernel/bpf/syscall.c:0:9)
bpf_prog_load+0x593 (kernel/bpf/syscall.c:2908:6)
bpf_check+0x1066 (kernel/bpf/verifier.c:21608:8)
. do_check_main (kernel/bpf/verifier.c:20938:8)
76us [0] do_check_common+0x552 (kernel/bpf/verifier.c:20856:9)
! 2us [-ENOENT] pop_stack
```
### `bpftrace`
[`bpftrace`](https://github.com/bpftrace/bpftrace) is a high level tracing
language for BPF. When working with sched_ext `bpftrace` programs can be used
for understanding scheduler run queue latency as other scheduler internals. See
the `scripts` dir for examples.
### `bpftop`
[`bpftop`](https://github.com/Netflix/bpftop) is a top/htop like program that
provides an overview of bpf program usage. It shows period and total average
runtime for each eBPF program, which is useful in understanding each scheduler
subprogram.
### `stress-ng`
For generating synthetic load on a system
[`stress-ng`](https://github.com/ColinIanKing/stress-ng) can be used.
`stress-ng` can generate different types of load on the system including cpu
bound, fork heavy, NUMA, cache heavy and more.
### `veristat`
[`veristat`](https://github.com/libbpf/veristat) is a tool to provide statics
from the BPF verifier for BPF programs. It can also be used to compare
verification stats across runs. This is useful when trying to optimize BPF
programs for their instruction count.
### `turbostat`
[`turbostat`](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/tools/power/x86/turbostat)
is a tool for inspecting CPU frequency as well as power utilization. When
optimizing schedulers for energy performance `turbostat` can be used to
understand the energy required per operation.
scx-1.0.12/INSTALL.md 0000664 0000000 0000000 00000006627 15007705772 0014045 0 ustar 00root root 0000000 0000000 # Install Instructions by Distro
## Ubuntu
`sched_ext` support for Ubuntu is currently provided by the linux-unstable
kernel, available at
[ppa:canonical-kernel-team/unstable](https://launchpad.net/~canonical-kernel-team/+archive/ubuntu/unstable).
#### Upgrading to 25.04 (Plucky Puffin) - recommended
Currently, only the 25.04 release is supported. You can upgrade to 25.04
using the following command:
```
$ sudo do-release-upgrade -d
```
#### Enable ppa:canonical-kernel-team/unstable
```
$ sudo add-apt-repository -y --enable-source ppa:canonical-kernel-team/unstable
```
If you are **not** on Ubuntu 25.04, make sure to select `plucky` as the release
for the linux-unstable ppa:
```
$ sudo sed -i "s/^Suites: .*/Suites: plucky/" \
/etc/apt/sources.list.d/canonical-kernel-team-ubuntu-unstable-plucky.sources
```
#### Installing the linux-unstable Kernel
```
$ sudo apt install -y linux-generic-wip
$ sudo reboot
```
#### Setting up Dev Environment
```
$ sudo apt install -y build-essential meson cmake cargo rustc clang llvm pkg-config libelf-dev
```
#### Build the scx schedulers from source
```
$ git clone https://github.com/sched-ext/scx.git
$ cd scx
$ meson setup build
$ meson compile -C build
```
#### Install the scx schedulers from source
```
$ meson install -C build
```
## Arch Linux
```
sudo pacman -S scx-scheds
```
#### Setting Up Dev Environment
In addition to the packages from the previous step, install the following.
```
$ sudo pacman -Sy meson cargo bpf pahole
```
## Gentoo Linux
Make sure you build the kernel with the right configuration, installation
should be easy:
```
echo 'sys-kernel/scx ~amd64' >> /etc/portage/package.accept_keywords
emerge sys-kernel/scx
```
## Fedora
CachyOS provides a [community-maintained copr repository](https://copr.fedorainfracloud.org/coprs/bieszczaders/kernel-cachyos) for
CachyOS kernels which has sched-ext support.
#### Installing the Kernel
```sh
$ sudo dnf copr enable bieszczaders/kernel-cachyos
$ sudo dnf install kernel-cachyos kernel-cachyos-devel-matched
$ sudo setsebool -P domain_kernel_load_modules on # Necessary for loading kernel modules
$ sudo reboot
```
#### Installing the Schedulers
The schedulers package is hosted in [another copr](https://copr.fedorainfracloud.org/coprs/bieszczaders/kernel-cachyos-addons)
also maintained by the CachyOS community.
```sh
$ sudo dnf copr enable bieszczaders/kernel-cachyos-addons
$ sudo dnf install scx-scheds
```
Alternatively, we also provide a `-git` package that is synced daily to match the upstream repository.
#### Setting up Dev Environment
No additional steps needed here other than what is mentioned in the main README.md.
## Nix
From NixOS 24.11 onwards, `scx` is available on Nixpkgs. Using a kernel of version 6.12+ or later is required.
```nix
{
services.scx.enable = true;
services.scx.scheduler = "scx_lavd"; # default is "scx_rustland"
boot.kernelPackages = pkgs.linuxPackages_latest;
}
```
Then rebuild and reboot your system. You can check if the scheduler is running by:
```shell
systemctl status scx.service
```
## openSUSE Tumbleweed
The scx package is included in openSUSE Factory and can be installed directly from Tumbleweed.
#### Installing the Schedulers
All schedulers are provided in the scx package
Example:
```
$ sudo zypper install scx
$ sudo scx_rusty
```
#### Setting up Dev Environment
No additional steps needed here other than what is mentioned in the main README.md.
scx-1.0.12/LICENSE 0000664 0000000 0000000 00000043254 15007705772 0013417 0 ustar 00root root 0000000 0000000 GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Lesser General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and
modification follow.
GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License. The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language. (Hereinafter, translation is included without limitation in
the term "modification".) Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.
c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide
a warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of Sections
1 and 2 above on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than your
cost of physically performing source distribution, a complete
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.
5. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all. For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.
10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
Copyright (C)
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
Also add information on how to contact you by electronic and paper mail.
If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:
Gnomovision version 69, Copyright (C) year name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
`Gnomovision' (which makes passes at compilers) written by James Hacker.
, 1 April 1989
Ty Coon, President of Vice
This General Public License does not permit incorporating your program into
proprietary programs. If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library. If this is what you want to do, use the GNU Lesser General
Public License instead of this License.
scx-1.0.12/OVERVIEW.md 0000664 0000000 0000000 00000064725 15007705772 0014210 0 ustar 00root root 0000000 0000000 # Overview
[sched_ext](https://github.com/sched-ext/scx) is a Linux kernel feature which
enables implementing and dynamically loading safe kernel thread schedulers in
BPF.
The benefits of such a framework are multifaceted, with there being three main
axes where sched_ext is specifically designed to provide significant value:
1. Ease of experimentation and exploration: Enabling rapid iteration of new
scheduling policies.
2. Customization: Building application-specific schedulers which implement
policies that are not applicable to general-purpose schedulers.
3. Rapid scheduler deployments: Non-disruptive swap outs of scheduling
policies in production environments.
We'll begin by doing a deeper dive into the motivation of sched_ext in the
following [Motivation](#motivation) section. Following that, we'll provide some
deatils on the overall architecture of sched_ext in the [How](#how) section
below.
# Motivation
## 1. Ease of experimentation and exploration
### Why is exploration important?
Scheduling is a challenging problem space. Small changes in scheduling behavior
can have a significant impact on various components of a system, with the
corresponding effects varying widely across different platforms, architectures,
and workloads.
While complexities have always existed in scheduling, they have increased
dramatically over the past 10-15 years. In the mid-late 2000s, cores were
typically homogeneous and further apart from each other, with the criteria for
scheduling being roughly the same across the entire die.
Systems in the modern age are by comparison much more complex. Modern CPU
designs, where the total power budget of all CPU cores often far exceeds the
power budget of the socket, with dynamic frequency scaling, and with or without
chiplets, have significantly expanded the scheduling problem space. Cache
hierarchies have become less uniform, with Core Complex (CCX) designs such as
recent AMD processors having multiple shared L3 caches within a single socket.
Such topologies resemble NUMA sans persistent NUMA node stickiness.
Use-cases have become increasingly complex and diverse as well. Applications
such as mobile and VR have strict latency requirements to avoid missing
deadlines that impact user experience. Stacking workloads in servers is
constantly pushing the demands on the scheduler in terms of workload isolation
and resource distribution.
Experimentation and exploration are important for any non-trivial problem
space. However, given the recent hardware and software developments, we believe
that experimentation and exploration are not just important, but _critical_ in
the scheduling problem space.
Indeed, other approaches in industry are already being explored. AMD has
proposed an experimental [patch
set](https://lore.kernel.org/lkml/20220910105326.1797-1-kprateek.nayak@amd.com/)
which enables userspace to provide hints to the scheduler via "Userspace
Hinting". The approach adds a prctl() API which allows callers to set a
numerical "hint" value on a struct task_struct. This hint is then optionally
read by the scheduler to adjust the cost calculus for various scheduling
decisions.
Huawei have also [expressed
interest](https://lore.kernel.org/bpf/dedc7b72-9da4-91d0-d81d-75360c177188@huawei.com/)
in enabling some form of programmable scheduling. While we're unaware of any
patch sets which have been sent to the upstream list for this proposal, it
similarly illustrates the need for more flexibility in the scheduler.
Additionally, Google has developed
[ghOSt](https://dl.acm.org/doi/pdf/10.1145/3477132.3483542) with the goal of
enabling custom, userspace driven scheduling policies. Prior
[presentations](https://lpc.events/event/16/contributions/1365/) at LPC have
discussed ghOSt and how BPF can be used to accelerate scheduling.
### Why can't we just explore directly with CFS?
Experimenting with CFS directly or implementing a new sched_class from scratch
is of course possible, but is often difficult and time consuming. Newcomers to
the scheduler often require years to understand the codebase and become
productive contributors. Even for seasoned kernel engineers, experimenting with
and upstreaming features can take a very long time. The iteration process
itself is also time consuming, as testing scheduler changes on real hardware
requires reinstalling the kernel and rebooting the host.
Core scheduling is an example of a feature that took a significant amount of
time and effort to integrate into the kernel. Part of the difficulty with core
scheduling was the inherent mismatch in abstraction between the desire to
perform core-wide scheduling, and the per-cpu design of the kernel scheduler.
This caused issues, for example ensuring proper fairness between the
independent runqueues of SMT siblings.
The high barrier to entry for working on the scheduler is an impediment to
academia as well. Master's/PhD candidates who are interested in improving the
scheduler will spend years ramping-up, only to complete their degrees just as
they're finally ready to make significant changes. A lower entrance barrier
would allow researchers to more quickly ramp up, test out hypotheses, and
iterate on novel ideas. Research methodology is also severely hampered by the
high barrier of entry to make modifications; for example, the
[Shenango](https://www.usenix.org/system/files/nsdi19-ousterhout.pdf) and
Shinjuku scheduling policies used sched affinity to replicate the desired
policy semantics, due to the difficulty of incorporating these policies into
the kernel directly.
The iterative process itself also imposes a significant cost to working on the
scheduler. Testing changes requires developers to recompile and reinstall the
kernel, reboot their machines, rewarm their workloads, and then finally rerun
their benchmarks. Though some of this overhead could potentially be mitigated
by enabling schedulers to be implemented as kernel modules, a machine crash or
subtle system state corruption is always only one innocuous mistake away.
These problems are exacerbated when testing production workloads in a
datacenter environment as well, where multiple hosts may be involved in an
experiment; requiring a significantly longer ramp up time. Warming up memcache
instances in the Meta production environment takes hours, for example.
### How does sched_ext help with exploration?
sched_ext attempts to address all of the problems described above. In this
section, we'll describe the benefits to experimentation and exploration that
are afforded by sched_ext, provide real-world examples of those benefits, and
discuss some of the trade-offs and considerations in our design choices.
One of our main goals was to lower the barrier to entry for experimenting
with the scheduler. sched_ext provides ergonomic callbacks and helpers to
ease common operations such as managing idle CPUs, scheduling tasks on
arbitrary CPUs, handling preemptions from other scheduling classes, and
more. While sched_ext does require some ramp-up, the complexity is
self-contained, and the learning curve gradual. Developers can ramp up by
first implementing simple policies such as global weighted vtime scheduling
in only tens of lines of code, and then continue to learn the APIs and
building blocks available with sched_ext as they build more featureful and
complex schedulers.
Another critical advantage provided by sched_ext is the use of BPF. BPF
provides strong safety guarantees by statically analyzing programs at load
time to ensure that they cannot corrupt or crash the system. sched_ext
guarantees system integrity no matter what BPF scheduler is loaded, and
provides mechanisms to safely disable the current BPF scheduler and migrate
tasks back to a trusted scheduler. For example, we also implement in-kernel
safety mechanisms to guarantee that a misbehaving scheduler cannot
indefinitely starve tasks. BPF also enables sched_ext to significantly improve
iteration speed for running experiments. Loading and unloading a BPF scheduler
is simply a matter of running and terminating a sched_ext binary.
BPF also provides programs with a rich set of APIs, such as maps, kfuncs, and
BPF helpers. In addition to providing useful building blocks to programs that
run entirely in kernel space (such as many of our example schedulers), these
APIs also allow programs to leverage user space in making scheduling decisions.
Specifically, the Atropos sample scheduler has a relatively simple weighted
vtime or FIFO scheduling layer in BPF, paired with a load balancing component
in userspace written in Rust. As described in more detail below, we also built
a more general user-space scheduling framework called "rhone" by leveraging
various BPF features.
On the other hand, BPF does have shortcomings, as can be plainly seen from the
complexity in some of the example schedulers. scx_pair.bpf.c illustrates this
point well. To start, it requires a good amount of code to emulate
cgroup-local-storage. In the kernel proper, this would simply be a matter of
adding another pointer to the struct cgroup, but in BPF, it requires a complex
juggling of data amongst multiple different maps, a good amount of boilerplate
code, and some unwieldy `bpf_loop()`'s and atomics. The code is also littered
with explicit and often unnecessary sanity checks to appease the verifier.
That being said, BPF is being rapidly improved. For example, Yonghong Song
recently upstreamed a
[patch set](https://lore.kernel.org/bpf/20221026042835.672317-1-yhs@fb.com/) to
add a cgroup local storage map type, allowing scx_pair.bpf.c to be simplified.
There are plans to address other issues as well, such as providing
statically-verified locking, and avoiding the need for unnecessary sanity
checks. Addressing these shortcomings is a high priority for BPF, and as
progress continues to be made, we expect most deficiencies to be addressed in
the not-too-distant future.
Yet another exploration advantage of sched_ext is helping widening the scope
of experiments. For example, sched_ext makes it easy to defer CPU assignment
until a task starts executing, allowing schedulers to share scheduling queues
at any granularity (hyper-twin, CCX and so on). Additionally, higher level
frameworks can be built on top to further widen the scope. For example, the
aforementioned [rhone](https://github.com/Byte-Lab/rhone) library allows
implementing scheduling policies in user-space by encapsulating the complexity
around communicating scheduling decisions with the kernel. This allows taking
advantage of a richer programming environment in user-space, enabling
experimenting with, for instance, more complex mathematical models.
sched_ext also allows developers to leverage machine learning. At Meta, we
experimented with using machine learning to predict whether a running task
would soon yield its CPU. These predictions can be used to aid the scheduler in
deciding whether to keep a runnable task on its current CPU rather than
migrating it to an idle CPU, with the hope of avoiding unnecessary cache
misses. Using a tiny neural net model with only one hidden layer of size 16,
and a decaying count of 64 syscalls as a feature, we were able to achieve a 15%
throughput improvement on an Nginx benchmark, with an 87% inference accuracy.
## 2. Customization
This section discusses how sched_ext can enable users to run workloads on
application-specific schedulers.
### Why deploy custom schedulers rather than improving CFS?
Implementing application-specific schedulers and improving CFS are not
conflicting goals. Scheduling features explored with sched_ext which yield
beneficial results, and which are sufficiently generalizable, can and should
be integrated into CFS. However, CFS is fundamentally designed to be a general
purpose scheduler, and thus is not conducive to being extended with some
highly targeted application or hardware specific changes.
Targeted, bespoke scheduling has many potential use cases. For example, VM
scheduling can make certain optimizations that are infeasible in CFS due to
the constrained problem space (scheduling a static number of long-running
VCPUs versus an arbitrary number of threads). Additionally, certain
applications might want to make targeted policy decisions based on hints
directly from the application (for example, a service that knows the different
deadlines of incoming RPCs).
Google has also experimented with some promising, novel scheduling policies.
One example is "central" scheduling, wherein a single CPU makes all scheduling
decisions for the entire system. This allows most cores on the system to be
fully dedicated to running workloads, and can have significant performance
improvements for certain use cases. For example, central scheduling with VCPUs
can avoid expensive vmexits and cache flushes, by instead delegating the
responsibility of preemption checks from the tick to a single CPU. See
scx_central.bpf.c for a simple example of a central scheduling policy built in
sched_ext.
Some workloads also have non-generalizable constraints which enable
optimizations in a scheduling policy which would otherwise not be feasible.
For example,VM workloads at Google typically have a low overcommit ratio
compared to the number of physical CPUs. This allows the scheduler to support
bounded tail latencies, as well as longer blocks of uninterrupted time.
Yet another interesting use case is the scx_flatcg scheduler, which provides a
flattened hierarchical vtree for cgroups. This scheduler does not account for
thundering herd problems among cgroups, and therefore may not be suitable for
inclusion in CFS. However, in a simple benchmark using
[wrk](https://github.com/wg/wrk) on apache serving a CGI script calculating
sha1sum of a small file, it outperformed CFS by ~3% with CPU controller
disabled and by ~10% with two apache instances competing with 2:1 weight ratio
nested four level deep.
Certain industries require specific scheduling behaviors that do not apply
broadly. For example, ARINC 653 defines scheduling behavior that is widely used
by avionic software, and some out-of-tree implementations
(https://ieeexplore.ieee.org/document/7005306) have been built. While the
upstream community may decide to merge one such implementation in the future,
it would also be entirely reasonable to not do so given the narrowness of
use-case, and non-generalizable, strict requirements. Such cases can be well
served by sched_ext in all stages of the software development lifecycle --
development, testing, deployment and maintenance.
There are also classes of policy exploration, such as machine learning, or
responding in real-time to application hints, that are significantly harder
(and not necessarily appropriate) to integrate within the kernel itself.
### Won't this increase fragmentation?
We acknowledge that to some degree, sched_ext does run the risk of increasing
the fragmentation of scheduler implementations. As a result of exploration,
however, we believe that enabling the larger ecosystem to innovate will
ultimately accelerate the overall development and performance of Linux.
BPF programs are required to be GPLv2, which is enforced by the verifier on
program loads. With regards to API stability, just as with other semi-internal
interfaces such as BPF kfuncs, we won't be providing any API stability
guarantees to BPF schedulers. While we intend to make an effort to provide
compatibility when possible, we will not provide any explicit, strong
guarantees as the kernel typically does with e.g. UAPI headers. For users who
decide to keep their schedulers out-of-tree,the licensing and maintenance
overheads will be fundamentally the same as for carrying out-of-tree patches.
With regards to the schedulers included in this patch set, and any other
schedulers we implement in the future, both Meta and Google will open-source
all of the schedulers we implement which have any relevance to the broader
upstream community. We expect that some of these, such as the simple example
schedulers and scx_rusty scheduler, will be upstreamed as part of the kernel
tree. Distros will be able to package and release these schedulers with the
kernel, allowing users to utilize these schedulers out-of-the-box without
requiring any additional work or dependencies such as clang or building the
scheduler programs themselves. Other schedulers and scheduling frameworks such
as rhone may be open-sourced through separate per-project repos.
## 3. Rapid scheduler deployments
Rolling out kernel upgrades is a slow and iterative process. At a large scale
it can take months to roll a new kernel out to a fleet of servers. While this
latency is expected and inevitable for normal kernel upgrades, it can become
highly problematic when kernel changes are required to fix bugs.
[Livepatch](https://www.kernel.org/doc/html/latest/livepatch/livepatch.html) is
available to quickly roll out critical security fixes to large fleets, but the
scope of changes that can be applied with livepatching is fairly limited, and
would likely not be usable for patching scheduling policies. With sched_ext,
new scheduling policies can be rapidly rolled out to production environments.
As an example, one of the variants of the [L1 Terminal Fault
(L1TF)](https://www.intel.com/content/www/us/en/architecture-and-technology/l1tf.html)
vulnerability allows a VCPU running a VM to read arbitrary host kernel memory
for pages in L1 data cache. The solution was to implement core scheduling,
which ensures that tasks running as hypertwins have the same "cookie".
While core scheduling works well, it took a long time to finalize and land
upstream. This long rollout period was painful, and required organizations to
make difficult choices amongst a bad set of options. Some companies such as
Google chose to implement and use their own custom L1TF-safe scheduler, others
chose to run without hyper-threading enabled, and yet others left
hyper-threading enabled and crossed their fingers.
Once core scheduling was upstream, organizations had to upgrade the kernels on
their entire fleets. As downtime is not an option for many, these upgrades had
to be gradually rolled out, which can take a very long time for large fleets.
An example of an sched_ext scheduler that illustrates core scheduling semantics
is scx_pair.bpf.c, which co-schedules pairs of tasks from the same cgroup, and
is resilient to L1TF vulnerabilities. While this example scheduler is certainly
not suitable for production in its current form, a similar scheduler that is
more performant and featureful could be written and deployed if necessary.
Rapid scheduling deployments can similarly be useful to quickly roll-out new
scheduling features without requiring kernel upgrades. At Google, for example,
it was observed that some low-priority workloads were causing degraded
performance for higher-priority workloads due to consuming a disproportionate
share of memory bandwidth. While a temporary mitigation was to use sched
affinity to limit the footprint of this low-priority workload to a small subset
of CPUs, a preferable solution would be to implement a more featureful
task-priority mechanism which automatically throttles lower-priority tasks
which are causing memory contention for the rest of the system. Implementing
this in CFS and rolling it out to the fleet could take a very long time.
sched_ext would directly address these gaps. If another hardware bug or
resource contention issue comes in that requires scheduler support to mitigate,
sched_ext can be used to experiment with and test different policies. Once a
scheduler is available, it can quickly be rolled out to as many hosts as
necessary, and function as a stop-gap solution until a longer-term mitigation
is upstreamed.
# How
sched_ext is a new sched_class which allows scheduling policies to be
implemented in BPF programs.
sched_ext leverages BPF's struct_ops feature to define a structure which
exports function callbacks and flags to BPF programs that wish to implement
scheduling policies. The struct_ops structure exported by sched_ext is struct
sched_ext_ops, and is conceptually similar to struct sched_class. The role of
sched_ext is to map the complex sched_class callbacks to the more simple and
ergonomic struct sched_ext_ops callbacks.
Unlike some other BPF program types which have ABI requirements due to
exporting UAPIs, struct_ops has no ABI requirements whatsoever. This provides
us with the flexibility to change the APIs provided to schedulers as necessary.
BPF struct_ops is also already being used successfully in other subsystems,
such as in support of TCP congestion control.
The only struct_ops field that is required to be specified by a scheduler is
the 'name' field. Otherwise, sched_ext will provide sane default behavior, such
as automatically choosing an idle CPU on the task wakeup path if .select_cpu()
is missing.
### Dispatch queues
To match the impedance between the scheduler core and the BPF scheduler,
sched_ext uses DSQs (dispatch queues) which can operate as both a FIFO and a
priority queue. By default, there is one global FIFO (``SCX_DSQ_GLOBAL``),
and one local dsq per CPU (``SCX_DSQ_LOCAL``). The BPF scheduler can manage
an arbitrary number of dsq's using ``scx_bpf_create_dsq()`` and
``scx_bpf_destroy_dsq()``.
A CPU always executes a task from its local DSQ. A task is "dispatched" to a
DSQ. A non-local DSQ is "consumed" to transfer a task to the consuming CPU's
local DSQ.
When a CPU is looking for the next task to run, if the local DSQ is not
empty, the first task is picked. Otherwise, the CPU tries to consume the
global DSQ. If that doesn't yield a runnable task either, ``ops.dispatch()``
is invoked.
### Scheduling cycle
The following briefly shows how a waking task is scheduled and executed.
1. When a task is waking up, ``ops.select_cpu()`` is the first operation
invoked. This serves two purposes. First, CPU selection optimization
hint. Second, waking up the selected CPU if idle.
The CPU selected by ``ops.select_cpu()`` is an optimization hint and not
binding. The actual decision is made at the last step of scheduling.
However, there is a small performance gain if the CPU
``ops.select_cpu()`` returns matches the CPU the task eventually runs on.
A side-effect of selecting a CPU is waking it up from idle. While a BPF
scheduler can wake up any cpu using the ``scx_bpf_kick_cpu()`` helper,
using ``ops.select_cpu()`` judiciously can be simpler and more efficient.
A task can be immediately dispatched to a DSQ from ``ops.select_cpu()`` by
calling ``scx_bpf_dispatch()``. If the task is dispatched to
``SCX_DSQ_LOCAL`` from ``ops.select_cpu()``, it will be dispatched to the
local DSQ of whichever CPU is returned from ``ops.select_cpu()``.
Additionally, dispatching directly from ``ops.select_cpu()`` will cause the
``ops.enqueue()`` callback to be skipped.
Note that the scheduler core will ignore an invalid CPU selection, for
example, if it's outside the allowed cpumask of the task.
2. Once the target CPU is selected, ``ops.enqueue()`` is invoked (unless the
task was dispatched directly from ``ops.select_cpu()``). ``ops.enqueue()``
can make one of the following decisions:
* Immediately dispatch the task to either the global or local DSQ by
calling ``scx_bpf_dispatch()`` with ``SCX_DSQ_GLOBAL`` or
``SCX_DSQ_LOCAL``, respectively.
* Immediately dispatch the task to a custom DSQ by calling
``scx_bpf_dispatch()`` with a DSQ ID which is smaller than 2^63.
* Queue the task on the BPF side.
3. When a CPU is ready to schedule, it first looks at its local DSQ. If
empty, it then looks at the global DSQ. If there still isn't a task to
run, ``ops.dispatch()`` is invoked which can use the following two
functions to populate the local DSQ.
* ``scx_bpf_dispatch()`` dispatches a task to a DSQ. Any target DSQ can
be used - ``SCX_DSQ_LOCAL``, ``SCX_DSQ_LOCAL_ON | cpu``,
``SCX_DSQ_GLOBAL`` or a custom DSQ. While ``scx_bpf_dispatch()``
currently can't be called with BPF locks held, this is being worked on
and will be supported. ``scx_bpf_dispatch()`` schedules dispatching
rather than performing them immediately. There can be up to
``ops.dispatch_max_batch`` pending tasks.
* ``scx_bpf_consume()`` tranfers a task from the specified non-local DSQ
to the dispatching DSQ. This function cannot be called with any BPF
locks held. ``scx_bpf_consume()`` flushes the pending dispatched tasks
before trying to consume the specified DSQ.
4. After ``ops.dispatch()`` returns, if there are tasks in the local DSQ,
the CPU runs the first one. If empty, the following steps are taken:
* Try to consume the global DSQ. If successful, run the task.
* If ``ops.dispatch()`` has dispatched any tasks, retry #3.
* If the previous task is an SCX task and still runnable, keep executing
it (see ``SCX_OPS_ENQ_LAST``).
* Go idle.
Note that the BPF scheduler can always choose to dispatch tasks immediately in
``ops.select_cpu()`` or ``ops.enqueue()``. If only the built-in DSQs are used,
there is no need to implement ``ops.dispatch()`` as a task is never queued on
the BPF scheduler and both the local and global DSQs are consumed
automatically.
``scx_bpf_dispatch()`` queues the task on the FIFO of the target DSQ. Use
``scx_bpf_dispatch_vtime()`` for the priority queue. Internal DSQs such as
``SCX_DSQ_LOCAL`` and ``SCX_DSQ_GLOBAL`` do not support priority-queue
dispatching, and must be dispatched to with ``scx_bpf_dispatch()``.
### Verifying callback behavior
sched_ext always verifies that any value returned from a callback is valid, and
will issue an error and unload the scheduler if it is not. For example, if
`.select_cpu()` returns an invalid CPU, or if an attempt is made to invoke the
`scx_bpf_dispatch()` with invalid enqueue flags. Furthermore, if a task remains
runnable for too long without being scheduled, sched_ext will detect it and
error-out the scheduler.
# Closing Thoughts
Both Meta and Google have experimented quite a lot with schedulers in the last
several years. Google has benchmarked various workloads using user space
scheduling, and have achieved performance wins by trading off generality for
application specific needs. At Meta, we are actively experimenting with
multiple production workloads and seeing significant performance gains, and are
in the process of deploying sched_ext schedulers on production workloads at
scale. We expect to leverage it extensively to run various experiments and
develop customized schedulers for a number of critical workloads.
# Written By
- David Vernet
- Josh Don
- Tejun Heo
- Barret Rhoden
# Supported By
- Paul Turner
- Neel Natu
- Patrick Bellasi
- Hao Luo
- Dimitrios Skarlatos
scx-1.0.12/README.md 0000664 0000000 0000000 00000047603 15007705772 0013673 0 ustar 00root root 0000000 0000000 # Sched_ext Schedulers and Tools
[sched_ext](https://github.com/sched-ext/scx) is a Linux kernel feature
which enables implementing kernel thread schedulers in BPF and dynamically
loading them. This repository contains various scheduler implementations and
support utilities.
sched_ext enables safe and rapid iterations of scheduler implementations, thus
radically widening the scope of scheduling strategies that can be experimented
with and deployed; even in massive and complex production environments.
You can find more information, links to blog posts and recordings, in the [wiki](https://github.com/sched-ext/scx/wiki).
The following are a few highlights of this repository.
- The [scx_layered case
study](https://github.com/sched-ext/scx/blob/case-studies/case-studies/scx_layered.md)
concretely demonstrates the power and benefits of sched_ext.
- For a high-level but thorough overview of the sched_ext (especially its
motivation), please refer to the [overview document](OVERVIEW.md).
- For a description of the schedulers shipped with this tree, please refer to
the [schedulers document](scheds/README.md).
- The following video is the [scx_rustland](https://github.com/sched-ext/scx/tree/main/scheds/rust/scx_rustland)
scheduler which makes most scheduling decisions in userspace Rust code showing
better FPS in terraria while kernel is being compiled. This doesn't mean that
scx_rustland is a better scheduler but does demonstrate how safe and easy it is to
implement a scheduler which is generally usable and can outperform the default
scheduler in certain scenarios.
[scx_rustland-terraria](https://github.com/sched-ext/scx/assets/1051723/42ec3bf2-9f1f-4403-80ab-bf5d66b7c2d5)
sched_ext is supported by the upstream kernel starting from version 6.12. Both
Meta and Google are fully committed to sched_ext and Meta is in the process of
mass production deployment. See (#kernel-feature-status) for more details.
In all example shell commands, `$SCX` refers to the root of this repository.
## Getting Started
All that's necessary for running sched_ext schedulers is a kernel with
sched_ext support and the scheduler binaries along with the libraries they
depend on. Switching to a sched_ext scheduler is as simple as running a
sched_ext binary:
```
root@test ~# cat /sys/kernel/sched_ext/state /sys/kernel/sched_ext/*/ops 2>/dev/null
disabled
root@test ~# scx_simple
local=1 global=0
local=74 global=15
local=78 global=32
local=82 global=42
local=86 global=54
^Zfish: Job 1, 'scx_simple' has stopped
root@test ~# cat /sys/kernel/sched_ext/state /sys/kernel/sched_ext/*/ops 2>/dev/null
enabled
simple
root@test ~# fg
Send job 1 (scx_simple) to foreground
local=635 global=179
local=696 global=192
^CEXIT: BPF scheduler unregistered
```
[`scx_simple`](https://github.com/sched-ext/scx/blob/main/scheds/c/scx_simple.bpf.c)
is a very simple global vtime scheduler which can behave acceptably on CPUs
with a simple topology (single socket and single L3 cache domain).
Above, we switch the whole system to use `scx_simple` by running the binary,
suspend it with `ctrl-z` to confirm that it's loaded, and then switch back
to the kernel default scheduler by terminating the process with `ctrl-c`.
For `scx_simple`, suspending the scheduler process doesn't affect scheduling
behavior because all that the userspace component does is print statistics.
This doesn't hold for all schedulers.
In addition to terminating the program, there are two more ways to disable a
sched_ext scheduler - `sysrq-S` and the watchdog timer. Ignoring kernel
bugs, the worst damage a sched_ext scheduler can do to a system is starving
some threads until the watchdog timer triggers.
As illustrated, once the kernel and binaries are in place, using sched_ext
schedulers is straightforward and safe. While developing and building
schedulers in this repository isn't complicated either, sched_ext makes use
of many new BPF features, some of which require build tools which are newer
than what many distros are currently shipping. This should become less of an
issue in the future. For the time being, the following custom repositories
are provided for select distros.
## Install Instructions by Distro
- [Ubuntu](INSTALL.md#ubuntu)
- [Arch Linux](INSTALL.md#arch-linux)
- [Gentoo Linux](INSTALL.md#gentoo-linux)
- [Fedora](INSTALL.md#fedora)
- [Nix](INSTALL.md#nix)
- [openSUSE Tumbleweed](INSTALL.md#opensuse-tumbleweed)
## Repository Structure
```
scx
|-- scheds : Sched_ext scheduler implementations
| |-- include : Shared BPF and user C include files including vmlinux.h
| |-- c : Example schedulers - userspace code written C
| \-- rust : Example schedulers - userspace code written Rust
\-- rust : Rust support code
\-- scx_utils : Common utility library for rust schedulers
```
## Build & Install
`meson` is the main build system but each Rust sub-project is its own
self-contained cargo project and can be built and published separately. The
following are the dependencies and version requirements.
**Note**: Many distros only have earlier versions of `meson`, in that case just [clone the meson
repo](https://mesonbuild.com/Quick-guide.html#installation-from-source) and call
`meson.py` e.g. `/path/to/meson/repo/meson.py compile -C build`. Alternatively, use `pip` e.g.
`pip install meson` or `pip install meson --break-system-packages` (if needed).
- `meson`: >=1.2, build scripts under `meson-scripts/` use `bash` and
standard utilities including `awk`.
- `clang`: >=16 required, >=17 recommended
- `libbpf`: >=1.2.2 required, >=1.3 recommended (`RESIZE_ARRAY` support is
new in 1.3). It's preferred to link statically against the source from the libbpf git repo, which is cloned during setup.
- Rust toolchain: >=1.82
- `libelf`, `libz`, `libzstd` if linking against static `libbpf.a`
- `bpftool` By default this is cloned and built as part of the default build process. Alternatively it's usually available in `linux-tools-common`.
The kernel has to be built with the following configuration:
- `CONFIG_BPF=y`
- `CONFIG_BPF_EVENTS=y`
- `CONFIG_BPF_JIT=y`
- `CONFIG_BPF_SYSCALL=y`
- `CONFIG_DEBUG_INFO_BTF=y`
- `CONFIG_FTRACE=y`
- `CONFIG_SCHED_CLASS_EXT=y`
### Setting Up and Building
`meson` always uses a separate build directory. Running the following
commands in the root of the tree builds and installs all schedulers under
`~/bin`.
#### Static linking against libbpf (preferred)
```
$ cd $SCX
$ meson setup build --prefix ~
$ meson compile -C build
$ meson install -C build
```
Notes: `meson setup` will also clone both libbpf and bpftool repos and `meson compile` will build them both.
Make sure you have dependencies installed that allow you to compile from source!
##### Ubuntu/Debian
```
apt install build-essential libssl-dev llvm lld libelf-dev meson cargo rustc clang llvm cmake pkg-config protobuf-compiler
```
##### Arch Linux
```
pacman -S base-devel
```
### Static linking against system libbpf
Note, depending on your system configuration `libbpf_a` and `libbpf_h` may be
in different directories. The system libbpf version needs to match the minimum
libbpf version for scx.
```
$ cd $SCX
$ meson setup build --prefix ~ -D libbpf_a=/usr/lib64/libbpf.a -D libbpf_h=/usr/include/bpf/
$ meson compile -C build
$ meson install -C build
```
#### Dynamic linking against libbpf
```
$ cd $SCX
$ meson setup build --prefix ~ -D libbpf_a=disabled
$ meson compile -C build
$ meson install -C build
```
#### Using a different bpftool
This will check the system for an installed bpftool
```
$ meson setup build --prefix ~ -D bpftool=disabled
```
Using a custom built bpftool
```
$ meson setup build --prefix ~ -D bpftool=/path/to/bpftool
```
Note that `meson compile` step is not strictly necessary as `install`
implies `compile`. The above also will build debug binaries with
optimizations turned off, which is useful for development but they aren't
optimized and big. For actual use you want to build release binaries.
`meson` uses `-D` argument to specify build options. The configuration
options can be specified at `setup` time but can also be changed afterwards
and `meson` will do the right thing. To switch to release builds, run the
following in the build directory and then compile and install again.
```
$ meson configure -Dbuildtype=release
```
Running `meson configure` without any argument shows all current build
options. For more information on `meson` arguments and built-in options,
please refer to `meson --help` and its
[documentation](https://mesonbuild.com/Builtin-options.html).
### Building Specific Schedulers and Binary Locations
If you just want to build a subset of schedulers, you can specify the
scheduler names as arguments to `meson compile`. For example, if we just
want to build the simple example scheduler
`scheds/c/scx_simple` and the Rust userspace scheduler
`scheds/rust/scx_rusty`:
```
$ cd $SCX
$ meson setup build -Dbuildtype=release
$ meson compile -C build scx_simple scx_rusty
```
:warning: **If your system has `sccache` installed**: `meson` automatically
uses `sccache` if available. However, `sccache` fails in one of the build
steps. If you encounter this issue, disable `sccache` by specifying `CC`
directly - `$ CC=clang meson setup build -Dbuildtype=release`.
You can also specify `-v` if you want to see the commands being used:
```
$ meson compile -C build -v scx_pair
```
For C userspace schedulers such as the ones under `scheds/c`,
the built binaries are located in the same directory under the build root.
For example, here, the `scx_simple` binary can be found at
`$SCX/build/scheds/c/scx_simple`.
For Rust userspace schedulers such as the ones under `scheds/rust`, the
`scx_rusty` binary can be found at `$SCX/build/scheds/rust/release`.
### SCX specific build options
While the default options should work in most cases, it may be desirable to
override some of the toolchains and dependencies - e.g. to directly use
`libbpf` built from the kernel source tree. The following `meson` build
options can be used in such cases.
- `bpf_clang`: `clang` to use when compiling `.bpf.c`
- `bpftool`: `bpftool` to use when generating `.bpf.skel.h`. Set this to "disabled" to check the system for an already installed bpftool
- `libbpf_a`: Static `libbpf.a` to use. Set this to "disabled" to link libbpf dynamically
- `libbpf_h`: `libbpf` header directories, only meaningful with `libbpf_a` option
- `cargo`: `cargo` to use when building Rust sub-projects
- `cargo_home`: `CARGO_HOME` env to use when invoking `cargo`
- `offline`: Compilation step should not access the internet
- `enable_rust`: Enable the build of Rust sub-projects
For example, let's say you want to use `bpftool` and `libbpf` shipped in the
kernel tree located at `$KERNEL`. We need to build `bpftool` in the kernel
tree first, set up SCX build with the related options and then build &
install.
```
$ cd $KERNEL
$ make -C tools/bpf/bpftool
$ cd $SCX
$ BPFTOOL=$KERNEL/tools/bpf/bpftool
$ meson setup build -Dbuildtype=release -Dprefix=~/bin \
-Dbpftool=$BPFTOOL/bpftool \
-Dlibbpf_a=$BPFTOOL/libbpf/libbpf.a \
-Dlibbpf_h=$BPFTOOL/libbpf/include
$ meson install -C build
```
Note that we use `libbpf` which was produced as a part of `bpftool` build
process rather than building `libbpf` directly. This is necessary because
`libbpf` header files need to be installed for them to be in the expected
relative locations.
### Offline Compilation
Rust builds automatically download dependencies from `crates.io`; however,
some build environments might not allow internet access requiring all
dependencies to be available offline. The `fetch` target and `offline`
option are provided for such cases.
The following downloads all Rust dependencies into `$HOME/cargo-deps`.
```
$ cd $SCX
$ meson setup build -Dcargo_home=$HOME/cargo-deps
$ meson compile -C build fetch
```
The following builds the schedulers without accessing the internet. The
`build` directory doesn't have to be the same one. The only requirement is
that the `cargo_home` option points to a directory which contains the
content generated from the previous step.
```
$ cd $SCX
$ meson setup build -Dcargo_home=$HOME/cargo-deps -Doffline=true -Dbuildtype=release
$ meson compile -C build
```
### Working with Rust Sub-projects
Each Rust sub-project is its own self-contained cargo project. When building
as a part of this repository, `meson` invokes `cargo` with the appropriate
options and environment variables to sync the build environment. When
building separately by running `cargo build` directly in a sub-project
directory, it will automatically figure out build environment. Please take a
look at the
[`scx_utils::BpfBuilder`](https://docs.rs/scx_utils/latest/scx_utils/struct.BpfBuilder.html)
documentation for details.
For example, the following builds and runs the `scx_rusty` scheduler:
```
$ cd $SCX/scheds/rust/scx_rusty
$ cargo build --release
$ cargo run --release
```
Here too, the `build` step is not strictly necessary as it's implied by
`run`.
Note that Rust userspace schedulers are published on `crates.io` and can be
built and installed without cloning this repository as long as the necessary
toolchains are available. Simply run:
```
$ cargo install --locked scx_rusty
```
and `scx_rusty` will be built and installed as `~/.cargo/bin/scx_rusty`.
## Checking scx_stats
With the implementation of scx_stats, schedulers no longer display statistics by default. To display the statistics from the currently running scheduler, a manual user action is required.
Below are examples of how to do this.
- To check the scheduler statistics, use the
```
scx_SCHEDNAME --monitor $INTERVAL
```
for example 0.5 - this will print the output every half a second
```
scx_bpfland --monitor 0.5
```
Some schedulers may implement different or multiple monitoring options. Refer to --help of each scheduler for details.
Most schedulers also accept ` --stats $INTERVAL` to print the statistics directly from the scheduling instance.
#### Examples
- scx_bpfland
```
❯ scx_bpfland --monitor 5
[scx_bpfland] tasks -> run: 3/4 int: 2 wait: 3 | nvcsw: 3 | dispatch -> dir: 0 prio: 73 shr: 9
[scx_bpfland] tasks -> run: 4/4 int: 2 wait: 2 | nvcsw: 3 | dispatch -> dir: 1 prio: 3498 shr: 1385
[scx_bpfland] tasks -> run: 4/4 int: 2 wait: 2 | nvcsw: 3 | dispatch -> dir: 1 prio: 2492 shr: 1311
[scx_bpfland] tasks -> run: 4/4 int: 2 wait: 3 | nvcsw: 3 | dispatch -> dir: 2 prio: 3270 shr: 1748
```
- scx_rusty
```
❯ scx_rusty --monitor 5
###### Thu, 29 Aug 2024 14:42:37 +0200, load balance @ -265.1ms ######
cpu= 0.00 load= 0.17 mig=0 task_err=0 lb_data_err=0 time_used= 0.0ms
tot= 15 sync_prev_idle= 0.00 wsync= 0.00
prev_idle= 0.00 greedy_idle= 0.00 pin= 0.00
dir= 0.00 dir_greedy= 0.00 dir_greedy_far= 0.00
dsq=100.00 greedy_local= 0.00 greedy_xnuma= 0.00
kick_greedy= 0.00 rep= 0.00
dl_clamp=33.33 dl_preset=93.33
slice=20000us
direct_greedy_cpus=f
kick_greedy_cpus=f
NODE[00] load= 0.17 imbal= +0.00 delta= +0.00
DOM[00] load= 0.17 imbal= +0.00 delta= +0.00
```
- scx_lavd
```
❯ scx_lavd --monitor 5
| 12 | 1292 | 3 | 1 | 8510 | 37.6028 | 2.42068 | 99.1304 | 100 | 62.8907 | 100 | 100 | 62.8907 | performance | 100 | 0 | 0 |
| 13 | 2208 | 3 | 1 | 6142 | 33.3442 | 2.39336 | 98.7626 | 100 | 60.2084 | 100 | 100 | 60.2084 | performance | 100 | 0 | 0 |
| 14 | 941 | 3 | 1 | 5223 | 31.323 | 1.704 | 99.215 | 100.019 | 59.1614 | 100 | 100.019 | 59.1614 | performance | 100 | 0 | 0 |
```
- scx_rustland
```
❯ scx_rustland --monitor 5
[RustLand] tasks -> r: 1/4 w: 3 /3 | pf: 0 | dispatch -> u: 4 k: 0 c: 0 b: 0 f: 0 | cg: 0
[RustLand] tasks -> r: 1/4 w: 2 /2 | pf: 0 | dispatch -> u: 28385 k: 0 c: 0 b: 0 f: 0 | cg: 0
[RustLand] tasks -> r: 0/4 w: 4 /0 | pf: 0 | dispatch -> u: 25288 k: 0 c: 0 b: 0 f: 0 | cg: 0
[RustLand] tasks -> r: 0/4 w: 2 /0 | pf: 0 | dispatch -> u: 30580 k: 0 c: 0 b: 0 f: 0 | cg: 0
[RustLand] tasks -> r: 0/4 w: 2 /0 | pf: 0 | dispatch -> u: 30824 k: 0 c: 0 b: 0 f: 0 | cg: 0
[RustLand] tasks -> r: 1/4 w: 1 /1 | pf: 0 | dispatch -> u: 33178 k: 0 c: 0 b: 0 f: 0 | cg: 0
```
## systemd services
See: [services](services/README.md)
## Kernel Feature Status
The kernel feature is not yet upstream and can be found in the
[sched_ext](https://github.com/sched-ext/sched_ext) repository. The
following are important branches:
- [`sched_ext`](https://github.com/sched-ext/sched_ext): The main development
branch. This branch periodically pulls from the
[bpf-next](https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git/)
tree to stay in sync with the kernel and BPF developments.
- `sched_ext-release-*`: sched_ext backports on top of released kernels. We
plan to maintain backports for a few recent kernel releases until
sched_ext is merged upstream. Currently maintained backports:
- [`sched_ext-release-v6.6`](https://github.com/sched-ext/sched_ext/tree/sched_ext-release-v6.6)
- `sched_ext-vN`: Patchsets posted upstream. The v4 LKML thread has
high-level discussions.
- [RFC](https://github.com/htejun/sched_ext):
[LMKL thread](http://lkml.kernel.org/r/20221130082313.3241517-1-tj@kernel.org)
- [`sched_ext-v2`](https://github.com/sched-ext/sched_ext/tree/sched_ext-v2):
[LKML thread](http://lkml.kernel.org/r/20230128001639.3510083-1-tj@kernel.org)
- [`sched_ext-v3`](https://github.com/sched-ext/sched_ext/tree/sched_ext-v3):
[LKML thread](http://lkml.kernel.org/r/20230317213333.2174969-1-tj@kernel.org)
- [`sched_ext-v4`](https://github.com/sched-ext/sched_ext/tree/sched_ext-v4):
[LKML thread](http://lkml.kernel.org/r/20230711011412.100319-1-tj@kernel.org)
- [`sched_ext-v5`](https://github.com/sched-ext/sched_ext/tree/sched_ext-v5):
[LKML thread](http://lkml.kernel.org/r/20231111024835.2164816-1-tj@kernel.org)
## [Breaking Changes](./BREAKING_CHANGES.md)
[A list of the breaking changes](./BREAKING_CHANGES.md) in the sched_ext kernel tree and the associated commits for the schedulers in this repo.
## [Developer Guide](./DEVELOPER_GUIDE.md)
Want to learn how to develop a scheduler or find some useful tools for working
with schedulers? See the developer guide for more details.
## Getting in Touch
We aim to build a friendly and approachable community around sched_ext. You
can reach us through the following channels:
- github: https://github.com/sched-ext/scx
- Slack: [https://schedextworkspace.slack.com](https://join.slack.com/t/schedextworkspace/shared_invite/zt-24c4on3sk-sHlozdLfCZBODfwU6t6dbw)
- Reddit: https://reddit.com/r/sched_ext
We also hold weekly office hours every Tuesday. Please see the #office-hours
channel on slack for details. To join the slack community, you can use [this
link](https://bit.ly/scx_slack).
## Additional Resources
There are blog posts and articles about sched_ext, which helps you to explore
sched_ext in various ways. Followings are some examples:
- [LWN: The extensible scheduler class (February, 2023)](https://lwn.net/Articles/922405/)
- [arighi's blog: Implement your own kernel CPU scheduler in Ubuntu with sched-ext (July, 2023)](https://arighi.blogspot.com/2023/07/implement-your-own-cpu-scheduler-in.html)
- [Changwoo's blog: sched_ext: a BPF-extensible scheduler class (Part 1) (December, 2023)](https://blogs.igalia.com/changwoo/sched-ext-a-bpf-extensible-scheduler-class-part-1/)
- [arighi's blog: Getting started with sched-ext development (April, 2024)](https://arighi.blogspot.com/2024/04/getting-started-with-sched-ext.html)
- [Changwoo's blog: sched_ext: scheduler architecture and interfaces (Part 2) (June, 2024)](https://blogs.igalia.com/changwoo/sched-ext-scheduler-architecture-and-interfaces-part-2/)
- [arighi's YT channel: scx_bpfland Linux scheduler demo: topology awareness (August, 2024)](https://youtu.be/R-FEZOveG-I)
scx-1.0.12/cargo-publish.py 0000775 0000000 0000000 00000010374 15007705772 0015523 0 ustar 00root root 0000000 0000000 #!/usr/bin/python
import argparse
import os
import re
import subprocess
import sys
priority=['scx_stats', 'scx_stats_derive', 'scx_utils', 'scx_rustland_core', 'scx_p2dq']
skip=['scx_mitosis']
publish_args={'scx_rlfifo': ['--no-verify'],
'scx_rustland': ['--no-verify']}
verbose = False
def err(line):
raise Exception(line)
def dbg(line):
if verbose:
print('[DBG] ' + line, file=sys.stderr)
def underline(string):
return f'\033[4m{string}\033[0m'
def get_rust_paths():
result = subprocess.run(['git', 'ls-files'], stdout=subprocess.PIPE)
lines = result.stdout.decode('utf-8').splitlines()
paths = []
for line in lines:
if line.endswith('Cargo.toml'):
paths.append(line)
return paths
def cargo_path_to_crate(path):
return path.split('/')[-2]
def cargo_is_workspace(path):
with open(path, 'r') as f:
lines = f.readlines()
for lineno, line in enumerate(lines):
workspace_re = r'(^\s*)(\[\s*workspace\s*\])(.*$)'
m = re.match(workspace_re, line)
if m:
dbg(f'[{path}:{lineno}] SKIP: {m.group(1)}{underline(m.group(2))}{m.group(3)}')
return True
return False
def publish(path, extra_args, ignore_existing):
directory = os.path.dirname(path)
try:
proc = subprocess.run(['cargo', 'publish'] + extra_args, cwd=directory,
check=True, capture_output=True)
except subprocess.CalledProcessError as e:
stdout = e.stdout.decode('utf-8').splitlines()
stderr = e.stderr.decode('utf-8').splitlines()
okay = False
if ignore_existing:
already_re = r'(^.*)(crate.*already uploaded)(.*$)'
m = re.match(already_re, stderr[-1])
if m:
print(f'IGNORE: {m.group(1)}{underline(m.group(2))}{m.group(3)}')
okay = True
if verbose or not okay:
for line in stdout:
print(f'STDOUT: {line}')
for line in stderr:
print(f'STDERR: {line}')
if not okay:
raise e
def main():
parser = argparse.ArgumentParser(prog='cargo-publish.py',
description='Publish rust projects, use --dry to see what it\'s going to do')
parser.add_argument('-s', '--start',
help='skip crates which come before this crate in the publishing order')
parser.add_argument('-i', '--ignore', action='store_true',
help='ignore errors from already published crates')
parser.add_argument('-d', '--dry', action='store_true')
parser.add_argument('-v', '--verbose', action='store_true')
args = parser.parse_args()
global verbose
verbose = args.verbose
paths = get_rust_paths()
crate_path_args = {}
for path in paths:
if cargo_is_workspace(path):
continue
crate = cargo_path_to_crate(path)
pargs = []
if crate in publish_args:
pargs = publish_args[crate]
del publish_args[crate]
crate_path_args[crate] = [path, pargs]
if len(publish_args):
err(f'publish_args contains non-existent crates {publish_args}')
if args.start and args.start not in crate_path_args:
err(f'--start specified non-existent crate {args.start}')
for crate in skip:
if crate not in crate_path_args:
err(f'{crate} is in skip list but does not exist')
del crate_path_args[crate]
# Fill targets in publishing order
targets = []
for pri in priority:
if pri not in crate_path_args:
err(f'cannot find cargo path for priority crate {pri}')
path_args = crate_path_args[pri]
targets.append([pri, [path_args[0], path_args[1]]])
del crate_path_args[pri]
for crate, path_args in sorted(crate_path_args.items()):
targets.append([crate, [path_args[0], path_args[1]]])
# Publish
start_from = args.start
for target in targets:
if start_from and target[0] != start_from:
continue
start_from = None
print(f'Publishing crate {target[0]} {" ".join(target[1][1])}')
dbg(f'target: {target}')
if not args.dry:
publish(target[1][0], target[1][1], args.ignore)
main()
scx-1.0.12/kernel-versions.json 0000664 0000000 0000000 00000002475 15007705772 0016433 0 ustar 00root root 0000000 0000000 {
"sched_ext/for-next": {
"repo": "https://git.kernel.org/pub/scm/linux/kernel/git/tj/sched_ext.git",
"branch": "for-next",
"commitHash": "92e91bb0495f725e2647c00b9aacf81b5b7dc73f",
"lastModified": 1746676297,
"narHash": "sha256-dm/4mMWp7sjAjyHBGe2r1OCvhMDf2yhUrC+IhFNqtAc=",
"kernelVersion": "6.14.0"
},
"bpf/bpf-next": {
"repo": "https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git",
"branch": "master",
"commitHash": "c8ce7db0ca83745a6b439c8b22cba49b7fb095e2",
"lastModified": 1746848805,
"narHash": "sha256-wtSitLOp1LwbWgJOLOCxQCm6y8ZeNUXhEfWkKF+GjzQ=",
"kernelVersion": "6.15.0-rc4"
},
"stable/6_12": {
"repo": "https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git",
"branch": "linux-6.12.y",
"commitHash": "f08cdc6cc92e3d23a05745f0f12f8caa348a27b4",
"lastModified": 1746848806,
"narHash": "sha256-xU1lzXgsUMsICyTVWx84LLSCae3DvWpv5wjYmtkIsLs=",
"kernelVersion": "6.12.28"
},
"stable/linux-rolling-stable": {
"repo": "https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git",
"branch": "linux-rolling-stable",
"commitHash": "392c8e00cced35ed6f84559b2c12cc07fae012e3",
"lastModified": 1746848801,
"narHash": "sha256-UMakHuP1j7mPbp5NsPCidknqYK4+FCzMYBniBq0ZPGw=",
"kernelVersion": "6.14.6"
}
} scx-1.0.12/lib/ 0000775 0000000 0000000 00000000000 15007705772 0013150 5 ustar 00root root 0000000 0000000 scx-1.0.12/lib/cpumask.bpf.c 0000664 0000000 0000000 00000010214 15007705772 0015523 0 ustar 00root root 0000000 0000000 #include
#include
#include
#include
static struct scx_allocator scx_bitmap_allocator;
size_t mask_size;
__weak
int scx_bitmap_init(__u64 total_mask_size)
{
mask_size = div_round_up(total_mask_size, 8);
return scx_alloc_init(&scx_bitmap_allocator, mask_size * 8 + sizeof(union sdt_id));
}
__weak
u64 scx_bitmap_alloc_internal(void)
{
struct sdt_data __arena *data = NULL;
scx_bitmap_t mask;
int i;
data = scx_alloc(&scx_bitmap_allocator);
if (unlikely(!data))
return (u64)(NULL);
mask = (scx_bitmap_t)data->payload;
mask->tid = data->tid;
bpf_for(i, 0, mask_size) {
mask->bits[i] = 0ULL;
}
return (u64)mask;
}
/*
* XXXETSAL: Ideally these functions would have a void return type,
* but as of 6.13 the verifier requires global functions to return a scalar.
*/
__weak
int scx_bitmap_free(scx_bitmap_t __arg_arena mask)
{
scx_arena_subprog_init();
scx_alloc_free_idx(&scx_bitmap_allocator, mask->tid.idx);
return 0;
}
__weak
int scx_bitmap_copy_to_stack(struct scx_bitmap *dst, scx_bitmap_t __arg_arena src)
{
int i;
if (unlikely(!src || !dst)) {
scx_bpf_error("invalid pointer args to pointer copy");
return 0;
}
bpf_for(i, 0, mask_size) {
if (i >= SCXMASK_NLONG || i < 0)
return 0;
dst->bits[i] = src->bits[i];
}
return 0;
}
__weak
int scx_bitmap_set_cpu(u32 cpu, scx_bitmap_t __arg_arena mask)
{
mask->bits[cpu / 64] |= 1 << (cpu % 64);
return 0;
}
__weak
int scx_bitmap_clear_cpu(u32 cpu, scx_bitmap_t __arg_arena mask)
{
mask->bits[cpu / 64] &= 1 << ~(cpu % 64);
return 0;
}
__weak
bool scx_bitmap_test_cpu(u32 cpu, scx_bitmap_t __arg_arena mask)
{
return mask->bits[cpu / 64] & (1 << (cpu % 64));
}
__weak
int scx_bitmap_clear(scx_bitmap_t __arg_arena mask)
{
int i;
bpf_for(i, 0, mask_size) {
mask->bits[i] = 0;
}
return 0;
}
__weak
int scx_bitmap_and(scx_bitmap_t __arg_arena dst, scx_bitmap_t __arg_arena src1, scx_bitmap_t __arg_arena src2)
{
int i;
bpf_for(i, 0, mask_size) {
dst->bits[i] = src1->bits[i] & src2->bits[i];
}
return 0;
}
__weak
int scx_bitmap_or(scx_bitmap_t __arg_arena dst, scx_bitmap_t __arg_arena src1, scx_bitmap_t __arg_arena src2)
{
int i;
bpf_for(i, 0, mask_size) {
dst->bits[i] = src1->bits[i] | src2->bits[i];
}
return 0;
}
__weak
bool scx_bitmap_empty(scx_bitmap_t __arg_arena mask)
{
int i;
bpf_for(i, 0, mask_size) {
if (mask->bits[i])
return true;
}
return true;
}
__weak int
scx_bitmap_to_bpf(struct bpf_cpumask __kptr *bpfmask __arg_trusted,
scx_bitmap_t __arg_arena scx_bitmap)
{
struct scx_bitmap *tmp;
int ret;
tmp = scx_percpu_scx_bitmap_stack();
scx_bitmap_copy_to_stack(tmp, scx_bitmap);
ret = bpf_cpumask_populate((struct cpumask *)bpfmask, tmp->bits, sizeof(tmp->bits));
if (unlikely(ret))
scx_bpf_error("error %d when calling bpf_cpumask_populate", ret);
return 0;
}
__weak
int scx_bitmap_copy(scx_bitmap_t __arg_arena dst, scx_bitmap_t __arg_arena src)
{
int i;
bpf_for(i, 0, mask_size) {
dst->bits[i] = src->bits[i];
}
return 0;
}
__weak int
scx_bitmap_from_bpf(scx_bitmap_t __arg_arena scx_bitmap, const cpumask_t *bpfmask __arg_trusted)
{
int i;
for (i = 0; i < sizeof(cpumask_t) / 8 && can_loop; i++) {
if (i >= mask_size)
break;
scx_bitmap->bits[i] = bpfmask->bits[i];
}
return 0;
}
__weak
bool scx_bitmap_subset_cpumask(scx_bitmap_t __arg_arena big, const struct cpumask *small __arg_trusted)
{
scx_bitmap_t tmp = scx_percpu_scx_bitmap();
int i;
scx_bitmap_from_bpf(tmp, small);
bpf_for(i, 0, mask_size) {
if (~big->bits[i] & tmp->bits[i])
return false;
}
return true;
}
__weak
bool scx_bitmap_intersects_cpumask(scx_bitmap_t __arg_arena scx, const struct cpumask *bpf __arg_trusted)
{
scx_bitmap_t tmp = scx_percpu_scx_bitmap();
int i;
scx_bitmap_from_bpf(tmp, bpf);
bpf_for(i, 0, mask_size) {
if (scx->bits[i] & tmp->bits[i])
return true;
}
return false;
}
__weak
int scx_bitmap_and_cpumask(scx_bitmap_t dst __arg_arena,
scx_bitmap_t scx __arg_arena,
const struct cpumask *bpf __arg_trusted)
{
scx_bitmap_t tmp = scx_percpu_scx_bitmap();
scx_bitmap_from_bpf(tmp, bpf);
scx_bitmap_and(dst, scx, tmp);
return 0;
}
scx-1.0.12/lib/meson.build 0000664 0000000 0000000 00000001223 15007705772 0015310 0 ustar 00root root 0000000 0000000 libs = ['sdt_alloc', 'sdt_task']
objs = []
foreach src: libs
# Copy of gen_bpf_o(), because custom targets and generators don't mix
bpf_o = custom_target(src,
output: src + '.bpf.o',
input: src + '.bpf.c',
command: [bpf_clang, bpf_base_cflags, '-target', 'bpf', libbpf_c_headers, bpf_includes,
'-c', '@INPUT@', '-o', '@OUTPUT@'],
depends: [libbpf, bpftool_target]
)
objs += [bpf_o]
endforeach
scx_lib = custom_target(scx_lib_name,
output: scx_lib_name + '.bpf.o',
command: [compile_scx_lib, bpftool_exe_path, '@OUTPUT@', scx_lib_name, objs],
depends: objs,
)
scx-1.0.12/lib/sdt_alloc.bpf.c 0000664 0000000 0000000 00000100401 15007705772 0016022 0 ustar 00root root 0000000 0000000 /*
* SPDX-License-Identifier: GPL-2.0
* Copyright (c) 2024-2025 Meta Platforms, Inc. and affiliates.
* Copyright (c) 2024-2025 Tejun Heo
* Copyright (c) 2024-2025 Emil Tsalapatis
*/
#include
#include
#include
struct {
__uint(type, BPF_MAP_TYPE_ARENA);
__uint(map_flags, BPF_F_MMAPABLE);
#ifdef __TARGET_ARCH_arm64
__uint(max_entries, 1 << 16); /* number of pages */
__ulong(map_extra, (1ull << 32)); /* start of mmap() region */
#else
__uint(max_entries, 1 << 20); /* number of pages */
__ulong(map_extra, (1ull << 44)); /* start of mmap() region */
#endif
} arena __weak SEC(".maps");
struct scx_alloc_stack __arena *prealloc_stack;
/*
* Necessary for cond_break/can_loop's semantics. According to kernel commit
* 011832b, the loop counter variable must be seen as imprecise and bounded
* by the verifier. Initializing it from a constant (e.g., i = 0;), then,
* makes it precise and prevents may_goto from helping with converging the
* loop. For these loops we must initialize the loop counter from a variable
* whose value the verifier cannot reason about when checking the program, so
* that the loop counter's value is imprecise.
*/
static __u64 zero = 0;
/*
* XXX Hack to get the verifier to find the arena for sdt_exit_task.
* As of 6.12-rc5, The verifier associates arenas with programs by
* checking LD.IMM instruction operands for an arena and populating
* the program state with the first instance it finds. This requires
* accessing our global arena variable, but scx methods do not necessarily
* do so while still using pointers from that arena. Insert a bpf_printk
* statement that triggers at most once to generate an LD.IMM instruction
* to access the arena and help the verifier.
*/
static bool scx_arena_verify_once;
__hidden void scx_arena_subprog_init(void)
{
if (scx_arena_verify_once)
return;
bpf_printk("%s: arena pointer %p", __func__, &arena);
scx_arena_verify_once = true;
}
private(LOCK) struct bpf_spin_lock alloc_lock;
private(POOL_LOCK) struct bpf_spin_lock alloc_pool_lock;
/* allocation pools */
struct sdt_pool desc_pool;
struct sdt_pool chunk_pool;
/* Protected by alloc_lock. */
struct scx_alloc_stats alloc_stats;
static int scx_ffs(__u64 word)
{
unsigned int num = 0;
if ((word & 0xffffffff) == 0) {
num += 32;
word >>= 32;
}
if ((word & 0xffff) == 0) {
num += 16;
word >>= 16;
}
if ((word & 0xff) == 0) {
num += 8;
word >>= 8;
}
if ((word & 0xf) == 0) {
num += 4;
word >>= 4;
}
if ((word & 0x3) == 0) {
num += 2;
word >>= 2;
}
if ((word & 0x1) == 0) {
num += 1;
word >>= 1;
}
return num;
}
static
u64 scx_next_pow2(__u64 n)
{
n--;
n |= n >> 1;
n |= n >> 2;
n |= n >> 4;
n |= n >> 8;
n |= n >> 16;
n |= n >> 32;
n++;
return n;
}
/* find the first empty slot */
static __u64 chunk_find_empty(sdt_desc_t *desc)
{
__u64 freeslots;
__u64 i;
for (i = 0; i < SDT_TASK_CHUNK_BITMAP_U64S; i++) {
freeslots = ~desc->allocated[i];
if (freeslots == (__u64)0)
continue;
return (i * 64) + scx_ffs(freeslots);
}
return SDT_TASK_ENTS_PER_CHUNK;
}
static
void __arena *scx_alloc_stack_pop(struct scx_alloc_stack __arena *stack)
{
void __arena *slab;
/* Cannot print out diagnostic because we may be holding a lock. */
if (unlikely(stack->idx == 0))
return NULL;
stack->idx -= 1;
slab = stack->stack[stack->idx];
return slab;
}
static
int scx_alloc_stack(struct scx_alloc_stack __arena *stack)
{
void __arena *slab;
bpf_spin_lock(&alloc_lock);
if (stack->idx >= SDT_TASK_ALLOC_STACK_MIN)
return 0;
bpf_spin_unlock(&alloc_lock);
slab = bpf_arena_alloc_pages(&arena, NULL, 1, NUMA_NO_NODE, 0);
if (slab == NULL)
return -ENOMEM;
bpf_spin_lock(&alloc_lock);
/*
* Edge case where so many threads tried to allocate that our
* allocation does not fit into the stack.
*/
if (stack->idx >= SDT_TASK_ALLOC_STACK_MAX) {
bpf_spin_unlock(&alloc_lock);
bpf_arena_free_pages(&arena, slab, 1);
return -EAGAIN;
}
stack->stack[stack->idx] = slab;
stack->idx += 1;
alloc_stats.arena_pages_used += 1;
bpf_spin_unlock(&alloc_lock);
return -EAGAIN;
}
static __noinline
int scx_alloc_attempt(struct scx_alloc_stack __arena *stack)
{
int i;
/*
* Use can_loop to help with verification. The can_loop macro was
* introduced in kernel commit ba39486 and wraps around the may_goto
* instruction that helps with verifiying for loops. Using may_goto
* embeds a switch into the loop that ensures it is considered
* terminable by the verifier by adding a hidden switch to the loop
* and counting down with every iteration.
*/
for (i = zero; i < SDT_TASK_ALLOC_ATTEMPTS && can_loop; i++) {
if (scx_alloc_stack(stack) == 0)
return 0;
}
return -ENOMEM;
}
/* Allocate element from the pool. Must be called with a then pool lock held. */
static
void __arena *scx_alloc_from_pool(struct sdt_pool *pool,
struct scx_alloc_stack __arena *stack)
{
__u64 elem_size, max_elems;
void __arena *slab;
void __arena *ptr;
elem_size = pool->elem_size;
max_elems = pool->max_elems;
/* Nonsleepable allocations not supported for large data structures. */
if (elem_size > PAGE_SIZE)
return NULL;
/* If the chunk is spent, get a new one. */
if (pool->idx >= max_elems) {
slab = scx_alloc_stack_pop(stack);
pool->slab = slab;
pool->idx = 0;
}
ptr = (void __arena *)((__u64) pool->slab + elem_size * pool->idx);
pool->idx += 1;
return ptr;
}
/* Allocate element from the pool. Must be called with a then pool lock held. */
static
void __arena *scx_alloc_from_pool_sleepable(struct sdt_pool *pool)
{
__u64 elem_size, max_elems;
void __arena *slab;
void __arena *ptr;
elem_size = pool->elem_size;
max_elems = pool->max_elems;
/* If the chunk is spent, get a new one. */
if (pool->idx >= max_elems) {
slab = bpf_arena_alloc_pages(&arena, NULL,
div_round_up(max_elems * elem_size, PAGE_SIZE), NUMA_NO_NODE, 0);
pool->slab = slab;
pool->idx = 0;
}
ptr = (void __arena *)((__u64) pool->slab + elem_size * pool->idx);
pool->idx += 1;
return ptr;
}
/* Alloc desc and associated chunk. Called with the task spinlock held. */
static sdt_desc_t *scx_alloc_chunk(struct scx_alloc_stack __arena *stack)
{
struct sdt_chunk __arena *chunk;
sdt_desc_t *desc;
sdt_desc_t *out;
chunk = scx_alloc_from_pool(&chunk_pool, stack);
desc = scx_alloc_from_pool(&desc_pool, stack);
out = desc;
desc->nr_free = SDT_TASK_ENTS_PER_CHUNK;
desc->chunk = chunk;
alloc_stats.chunk_allocs += 1;
return out;
}
static int pool_set_size(struct sdt_pool *pool, __u64 data_size, __u64 nr_pages)
{
if (unlikely(data_size % 8)) {
scx_bpf_error("%s: allocation size %llu not word aligned", __func__, data_size);
return -EINVAL;
}
if (unlikely(nr_pages == 0)) {
scx_bpf_error("%s: allocation size is 0", __func__);
return -EINVAL;
}
pool->elem_size = data_size;
pool->max_elems = (PAGE_SIZE * nr_pages) / pool->elem_size;
/* Populate the pool slab on the first allocation. */
pool->idx = pool->max_elems;
return 0;
}
/* initialize the whole thing, maybe misnomer */
__hidden int
scx_alloc_init(struct scx_allocator *alloc, __u64 data_size)
{
size_t min_chunk_size;
int ret;
_Static_assert(sizeof(struct sdt_chunk) <= PAGE_SIZE,
"chunk size must fit into a page");
ret = pool_set_size(&chunk_pool, sizeof(struct sdt_chunk), 1);
if (ret != 0)
return ret;
ret = pool_set_size(&desc_pool, sizeof(struct sdt_desc), 1);
if (ret != 0)
return ret;
/* Wrap data into a descriptor and word align. */
data_size += sizeof(struct sdt_data);
data_size = round_up(data_size, 8);
/*
* Ensure we allocate large enough chunks from the arena to avoid excessive
* internal fragmentation when turning chunks it into structs.
*/
min_chunk_size = div_round_up(SDT_TASK_MIN_ELEM_PER_ALLOC * data_size, PAGE_SIZE);
ret = pool_set_size(&alloc->pool, data_size, min_chunk_size);
if (ret != 0)
return ret;
prealloc_stack = bpf_arena_alloc_pages(&arena, NULL, div_round_up(sizeof(*prealloc_stack), PAGE_SIZE), NUMA_NO_NODE, 0);
if (prealloc_stack == NULL)
return -ENOMEM;
/* On success, returns with the lock taken. */
ret = scx_alloc_attempt(prealloc_stack);
if (ret != 0)
return ret;
alloc->root = scx_alloc_chunk(prealloc_stack);
bpf_spin_unlock(&alloc_lock);
return 0;
}
static
int set_idx_state(sdt_desc_t *desc, __u64 pos, bool state)
{
__u64 __arena *allocated = desc->allocated;
__u64 bit;
if (unlikely(pos >= SDT_TASK_ENTS_PER_CHUNK))
return -EINVAL;
bit = (__u64)1 << (pos % 64);
if (state)
allocated[pos / 64] |= bit;
else
allocated[pos / 64] &= ~bit;
return 0;
}
static __noinline
int mark_nodes_avail(sdt_desc_t *lv_desc[SDT_TASK_LEVELS], __u64 lv_pos[SDT_TASK_LEVELS])
{
sdt_desc_t *desc;
__u64 u, level;
int ret;
for (u = zero; u < SDT_TASK_LEVELS && can_loop; u++) {
level = SDT_TASK_LEVELS - 1 - u;
/* Only propagate upwards if we are the parent's only free chunk. */
desc = lv_desc[level];
/* Failed calls return unlocked. */
ret = set_idx_state(desc, lv_pos[level], false);
if (unlikely(ret != 0))
return ret;
desc->nr_free += 1;
if (desc->nr_free > 1)
return 0;
}
return 0;
}
__weak
int scx_alloc_free_idx(struct scx_allocator *alloc, __u64 idx)
{
const __u64 mask = (1 << SDT_TASK_ENTS_PER_PAGE_SHIFT) - 1;
sdt_desc_t *lv_desc[SDT_TASK_LEVELS];
sdt_desc_t * __arena *desc_children;
struct sdt_chunk __arena *chunk;
sdt_desc_t *desc;
struct sdt_data __arena *data;
__u64 level, shift, pos;
__u64 lv_pos[SDT_TASK_LEVELS];
int ret;
int i;
scx_arena_subprog_init();
if (!alloc)
return 0;
bpf_spin_lock(&alloc_lock);
desc = alloc->root;
if (unlikely(!desc)) {
bpf_spin_unlock(&alloc_lock);
scx_bpf_error("%s: root not allocated", __func__);
return 0;
}
/* To appease the verifier. */
for (level = zero; level < SDT_TASK_LEVELS && can_loop; level++) {
lv_desc[level] = NULL;
lv_pos[level] = 0;
}
for (level = zero; level < SDT_TASK_LEVELS && can_loop; level++) {
shift = (SDT_TASK_LEVELS - 1 - level) * SDT_TASK_ENTS_PER_PAGE_SHIFT;
pos = (idx >> shift) & mask;
lv_desc[level] = desc;
lv_pos[level] = pos;
if (level == SDT_TASK_LEVELS - 1)
break;
chunk = desc->chunk;
desc_children = (sdt_desc_t * __arena *)chunk->descs;
desc = desc_children[pos];
if (unlikely(!desc)) {
bpf_spin_unlock(&alloc_lock);
scx_bpf_error("%s: freeing nonexistent idx [0x%llx] (level %llu)",
__func__, idx, level);
return 0;
}
}
chunk = desc->chunk;
pos = idx & mask;
data = chunk->data[pos];
if (likely(!data)) {
data[pos] = (struct sdt_data) {
.tid.genn = data->tid.genn + 1,
};
/* Zero out one word at a time. */
for (i = zero; i < alloc->pool.elem_size / 8 && can_loop; i++) {
data->payload[i] = 0;
}
}
ret = mark_nodes_avail(lv_desc, lv_pos);
if (unlikely(ret != 0)) {
bpf_spin_unlock(&alloc_lock);
return 0;
}
alloc_stats.active_allocs -= 1;
alloc_stats.free_ops += 1;
bpf_spin_unlock(&alloc_lock);
return 0;
}
/*
* Find and return an available idx on the allocator.
* Called with the task spinlock held.
*/
static sdt_desc_t * desc_find_empty(sdt_desc_t *desc,
struct scx_alloc_stack __arena *stack,
__u64 *idxp)
{
sdt_desc_t *lv_desc[SDT_TASK_LEVELS];
sdt_desc_t * __arena *desc_children;
struct sdt_chunk __arena *chunk;
sdt_desc_t *tmp;
__u64 lv_pos[SDT_TASK_LEVELS];
__u64 u, pos, level;
__u64 idx = 0;
int ret;
for (level = zero; level < SDT_TASK_LEVELS && can_loop; level++) {
pos = chunk_find_empty(desc);
/* Something has gone terribly wrong. */
if (unlikely(pos > SDT_TASK_ENTS_PER_CHUNK))
return NULL;
if (pos == SDT_TASK_ENTS_PER_CHUNK)
return NULL;
idx <<= SDT_TASK_ENTS_PER_PAGE_SHIFT;
idx |= pos;
/* Log the levels to complete allocation. */
lv_desc[level] = desc;
lv_pos[level] = pos;
/* The rest of the loop is for internal node traversal. */
if (level == SDT_TASK_LEVELS - 1)
break;
chunk = desc->chunk;
desc_children = (sdt_desc_t * __arena *)chunk->descs;
desc = desc_children[pos];
if (!desc) {
desc = scx_alloc_chunk(stack);
desc_children[pos] = desc;
}
}
for (u = zero; u < SDT_TASK_LEVELS && can_loop; u++) {
level = SDT_TASK_LEVELS - 1 - u;
tmp = lv_desc[level];
ret = set_idx_state(tmp, lv_pos[level], true);
if (ret != 0)
break;
tmp->nr_free -= 1;
if (tmp->nr_free > 0)
break;
}
*idxp = idx;
return desc;
}
static void scx_alloc_finish(struct sdt_data __arena *data, __u64 idx)
{
bpf_spin_lock(&alloc_lock);
/* The data counts as a chunk */
alloc_stats.data_allocs += 1;
alloc_stats.alloc_ops += 1;
alloc_stats.active_allocs += 1;
bpf_spin_unlock(&alloc_lock);
data->tid.idx = idx;
}
__weak
u64 scx_alloc_internal(struct scx_allocator *alloc)
{
struct scx_alloc_stack __arena *stack = prealloc_stack;
struct sdt_data __arena *data = NULL;
struct sdt_chunk __arena *chunk;
sdt_desc_t *desc;
__u64 idx, pos;
int ret;
if (!alloc)
return (u64)NULL;
/* On success, call returns with the lock taken. */
ret = scx_alloc_attempt(stack);
if (ret != 0)
return (u64)NULL;
/* We unlock if we encounter an error in the function. */
desc = desc_find_empty(alloc->root, stack, &idx);
bpf_spin_unlock(&alloc_lock);
if (unlikely(desc == NULL)) {
bpf_printk("%s: failed to find empty tree key", __func__);
return (u64)NULL;
}
chunk = desc->chunk;
/* Populate the leaf node if necessary. */
pos = idx & (SDT_TASK_ENTS_PER_CHUNK - 1);
data = chunk->data[pos];
if (!data) {
data = scx_alloc_from_pool_sleepable(&alloc->pool);
if (!data) {
scx_alloc_free_idx(alloc, idx);
bpf_printk("%s: failed to allocate data from pool", __func__);
return (u64)NULL;
}
}
chunk->data[pos] = data;
scx_alloc_finish(data, idx);
return (u64)data;
}
/*
* Static allocation module used to allocate arena memory for
* whose lifetime is that of the BPF program. Data is rarely
* allocated, mostly at program init, and never freed. The
* memory returned by this code is typeless so it avoids us
* having to define an allocator for each type.
*/
struct scx_static scx_static;
__hidden
void __arena *scx_static_alloc(size_t bytes, size_t alignment)
{
void __arena *memory, *old;
void __arena *ptr;
size_t padding;
u64 addr;
bpf_spin_lock(&alloc_lock);
/* Round up the current offset. */
addr = (__u64) scx_static.memory + scx_static.off;
padding = round_up(addr, alignment) - addr;
bytes += padding;
if (bytes > scx_static.max_alloc_bytes) {
bpf_spin_unlock(&alloc_lock);
scx_bpf_error("invalid request %ld, max is %ld\n", bytes,
scx_static.max_alloc_bytes);
return NULL;
}
/*
* The code assumes that the maximum static allocation
* size is significantly larger than the typical allocation
* size, so it does not attempt to alleviate memory
* fragmentation.
*/
if (scx_static.off + bytes > scx_static.max_alloc_bytes) {
old = scx_static.memory;
bpf_spin_unlock(&alloc_lock);
/*
* No free operation so just forget about the previous
* allocation memory.
*/
memory = bpf_arena_alloc_pages(&arena, NULL,
scx_static.max_alloc_bytes / PAGE_SIZE,
NUMA_NO_NODE, 0);
if (!scx_static.memory)
return NULL;
bpf_spin_lock(&alloc_lock);
/* Error out if we raced with another allocation. */
if (scx_static.memory != old) {
bpf_spin_unlock(&alloc_lock);
bpf_arena_free_pages(&arena, memory, scx_static.max_alloc_bytes);
scx_bpf_error("concurrent static memory allocations unsupported");
return NULL;
}
}
ptr = (void __arena *)(addr + padding);
scx_static.off += bytes;
bpf_spin_unlock(&alloc_lock);
return ptr;
}
__weak
int scx_static_init(size_t alloc_pages)
{
size_t max_bytes = alloc_pages * PAGE_SIZE;
void __arena *memory;
memory = bpf_arena_alloc_pages(&arena, NULL, alloc_pages, NUMA_NO_NODE, 0);
if (!memory)
return -ENOMEM;
bpf_spin_lock(&alloc_lock);
scx_static = (struct scx_static) {
.max_alloc_bytes = max_bytes,
.off = 0,
.memory = memory,
};
bpf_spin_unlock(&alloc_lock);
return 0;
}
__hidden
int scx_stk_init(struct scx_stk *stack, __u64 data_size, __u64 nr_pages_per_alloc)
{
if (!stack)
return -EINVAL;
stack->data_size = data_size;
stack->nr_pages_per_alloc = nr_pages_per_alloc;
stack->lock = scx_static_alloc(sizeof(*stack->lock), 1);
if (!stack->lock) {
scx_bpf_error("failed to allocate lock");
return -ENOMEM;
}
return 0;
}
static int scx_stk_push(struct scx_stk *stack, void __arena *elem)
{
scx_stk_seg_t *stk_seg = stack->current;
int ridx = stack->cind;
stack->current->elems[stack->cind] = elem;
ridx += 1;
/* Possibly loop into the next segment. */
if (ridx == SCX_STK_SEG_MAX) {
ridx = 0;
stk_seg = stk_seg->next;
if (!stk_seg)
return -ENOSPC;
}
stack->current = stk_seg;
stack->cind = ridx;
stack->capacity -= 1;
stack->available += 1;
return 0;
}
static
void __arena *scx_stk_pop(struct scx_stk *stack)
{
scx_stk_seg_t *stk_seg = stack->current;
void __arena *elem;
int ridx = stack->cind;
/* Possibly loop into previous next segment. */
if (ridx == 0) {
ridx = SCX_STK_SEG_MAX;
stk_seg = stack->current->prev;
/* Possibly loop back into the last segment. */
if (!stk_seg)
return NULL;
}
ridx -= 1;
stack->current = stk_seg;
stack->cind = ridx;
elem = stack->current->elems[stack->cind];
stack->capacity += 1;
stack->available -= 1;
return elem;
}
static
int scx_stk_seg_to_data(struct scx_stk *stack, size_t nelems)
{
int ret, i;
u64 data;
/* Do we have enough empty segments for the conversion? */
if (!stack->first || stack->first == stack->last)
return -ENOMEM;
data = (u64)stack->last;
stack->last->prev->next = NULL;
stack->last = stack->last->prev;
/* We removed a segment. */
stack->capacity -= SCX_STK_SEG_MAX;
for (i = zero; i < nelems && can_loop; i++) {
ret = scx_stk_push(stack, (void __arena *)data);
if (ret)
return ret;
data += stack->data_size;
}
return 0;
}
static
void scx_stk_extend(struct scx_stk *stack, scx_stk_seg_t *stk_seg)
{
if (stack->last)
stack->last->next = stk_seg;
stk_seg->prev = stack->last;
stk_seg->next = NULL;
stack->last = stk_seg;
stack->capacity += SCX_STK_SEG_MAX;
if (!stack->first)
stack->first = stk_seg;
/*
* Do not adjust the current segment/idx because we did not add
* any elements. The new segment will be pushed into during the next
* allocation.
*/
}
static
int scx_stk_free_unlocked(struct scx_stk *stack, void __arena *elem)
{
if (!stack)
return -EINVAL;
/* If no more room, repurpose the allocation into a segment. */
if (stack->capacity == 0) {
scx_stk_extend(stack, (scx_stk_seg_t *)elem);
return 0;
}
return scx_stk_push(stack, elem);
}
__weak
int scx_stk_free_internal(struct scx_stk *stack, __u64 elem)
{
int ret;
if (!stack)
return -EINVAL;
if ((ret = arena_spin_lock(stack->lock))) {
scx_bpf_error("spinlock error %d", ret);
return 0;
}
ret = scx_stk_free_unlocked(stack, (void __arena *)elem);
arena_spin_unlock(stack->lock);
return ret;
}
static
int scx_stk_get_arena_memory(struct scx_stk *stack, __u64 nr_pages, __u64 nstk_segs)
{
scx_stk_seg_t *stk_seg;
int ret, i;
u64 mem;
arena_spin_unlock(stack->lock);
/*
* The code allocates new memory only as segments. The allocation and
* free code freely typecasts the segment buffer into data that can be
* allocated, and vice versa to avoid either ending up with too many
* empty segments under memory pressure, or having no space in the segment
* buffer for a buffer currently being freed.
*/
/*
* On error, we return with the segment buffer unlocked. This is
* because arena_spin_lock can fail, so we cannot guarantee we
* can lock it back.
*/
if (!stack)
return -EINVAL;
mem = (__u64)bpf_arena_alloc_pages(&arena, NULL, nstk_segs * nr_pages, NUMA_NO_NODE, 0);
if (!mem)
return -ENOMEM;
if ((ret = arena_spin_lock(stack->lock))) {
bpf_arena_free_pages(&arena, (void __arena *)mem, nr_pages);
scx_bpf_error("spinlock error %d", ret);
return ret;
}
_Static_assert(sizeof(struct scx_stk_seg) <= PAGE_SIZE,
"segment must fit into a page");
/* Attach the segments to the reserve linked list. */
for (i = zero; i < nstk_segs && can_loop; i++) {
stk_seg = (scx_stk_seg_t *)mem;
stk_seg->next = stack->reserve;
stack->reserve = stk_seg;
mem += nr_pages * PAGE_SIZE;
}
return 0;
}
static
int scx_stk_fill_new_elems(struct scx_stk *stack)
{
size_t nelems, nstk_segs;
scx_stk_seg_t *stk_seg;
__u64 nr_pages;
int ret, i;
u64 mem;
nr_pages = stack->nr_pages_per_alloc;
nelems = (nr_pages * PAGE_SIZE) / stack->data_size;
if (nelems > SCX_STK_SEG_MAX) {
arena_spin_unlock(stack->lock);
scx_bpf_error("new elements must fit into a single segment");
return -EINVAL;
}
/* How many segments should we allocate? */
nstk_segs = stack->capacity ? 1 : 2;
/*
* If we have more than two empty segments available,
* repurpose one of them into an allocation.
*/
ret = scx_stk_seg_to_data(stack, nelems);
if (!ret)
return 0;
/* If we haven't set aside any memory from before, allocate. */
if (!stack->reserve) {
/* This call drops and retakes the lock. */
ret = scx_stk_get_arena_memory(stack, nr_pages, nstk_segs);
if (ret)
return ret;
}
/*
* If somebody replenished the stack while we were asleep, no need
* to do anything. Keep the allocated memory in the reserve linked
* list for subsequent allocations.
*/
if (stack->available > 0)
return 0;
/*
* Otherwise add elements and possibly capacity to the stack. */
if (!stack->capacity) {
stk_seg = stack->reserve;
stack->reserve = stack->reserve->next;
scx_stk_extend(stack, stk_seg);
}
/* Pop out the reserve and attach to the stack. */
stk_seg = stack->reserve;
stack->reserve = stk_seg->next;
mem = (u64)stk_seg;
for (i = zero; i < nelems && can_loop; i++) {
ret = scx_stk_push(stack, (void __arena *)mem);
if (ret) {
arena_spin_unlock(stack->lock);
return ret;
}
mem += stack->data_size;
}
return 0;
}
__weak
__u64 scx_stk_alloc(struct scx_stk *stack)
{
void __arena *elem;
int ret;
if (!stack) {
scx_bpf_error("using uninitialized stack allocator");
return 0ULL;
}
if ((ret = arena_spin_lock(stack->lock))) {
scx_bpf_error("spinlock error %d", ret);
return 0ULL;
}
/* If segment buffer is empty, we have to populate it. */
if (stack->available == 0) {
/* The call drops the lock on error. */
ret = scx_stk_fill_new_elems(stack);
if (ret) {
scx_bpf_error("elem creation failed");
return 0ULL;
}
}
elem = scx_stk_pop(stack);
arena_spin_unlock(stack->lock);
return (u64)elem;
}
static
void header_set_order(scx_buddy_chunk_t *chunk, u64 offset, u8 order)
{
if (order >= SCX_BUDDY_CHUNK_MAX_ORDER) {
scx_bpf_error("setting invalid order");
return;
}
if (offset >= SCX_BUDDY_CHUNK_ITEMS) {
scx_bpf_error("setting order of invalid offset");
return;
}
if (offset & 0x1)
order &= 0xf;
else
order <<= 4;
chunk->orders[offset / 2] |= order;
}
static
u8 header_get_order(scx_buddy_chunk_t *chunk, u64 offset)
{
u8 result;
_Static_assert(SCX_BUDDY_CHUNK_MAX_ORDER <= 16, "order must fit in 4 bits");
if (offset >= SCX_BUDDY_CHUNK_ITEMS) {
scx_bpf_error("setting order of invalid offset");
return SCX_BUDDY_CHUNK_MAX_ORDER;
}
result = chunk->orders[offset / 2];
return (offset & 0x1) ? (result & 0xf) : (result >> 4);
}
static
u64 size_to_order(size_t size)
{
u64 order;
/*
* To find the order of the allocation we find the first power of two
* >= the requested size, take the log2, then adjust it for the minimum
* allocation size by removing the minimum shift from it. Requests
* smaller than the minimum allocation size are rounded up.
*/
order = scx_ffs(scx_next_pow2(size));
if (order < SCX_BUDDY_MIN_ALLOC_SHIFT)
return 0;
return order - SCX_BUDDY_MIN_ALLOC_SHIFT;
}
static
void __arena *chunk_idx_to_mem(scx_buddy_chunk_t *chunk, size_t idx)
{
u64 address;
/*
* The data blocks start in the chunk after the metadata block.
* We find the actual address by indexing into the region at an
* SCX_BUDDY_MIN_ALLOC_BYTES granularity, the minimum allowed.
* The index number already accounts for the fact that the first
* blocks in the chunk are occupied by the metadata, so we do
* not need to offset it.
*/
address = (u64)chunk + (idx * SCX_BUDDY_MIN_ALLOC_BYTES);
return (void __arena *)address;
}
static
scx_buddy_header_t *chunk_get_header(scx_buddy_chunk_t *chunk, size_t idx)
{
return (scx_buddy_header_t *)chunk_idx_to_mem(chunk, idx);
}
static
scx_buddy_chunk_t *scx_buddy_chunk_get(struct scx_stk *stk)
{
u64 order, ord, last_order;
scx_buddy_header_t *header;
scx_buddy_chunk_t *chunk;
u32 idx, cur_idx;
int i, power2;
size_t left;
chunk = (scx_buddy_chunk_t *)scx_stk_alloc(stk);
if (!chunk)
return NULL;
/*
* Initialize the chunk by carving out the first page to hold the metadata struct above,
* then dumping the rest of the pages into the allocator.
*/
bpf_for (i, 0, SCX_BUDDY_CHUNK_ITEMS) {
header = chunk_get_header(chunk, i);
header->prev_index = SCX_BUDDY_CHUNK_ITEMS;
header->next_index = SCX_BUDDY_CHUNK_ITEMS;
header_set_order(chunk, i, SCX_BUDDY_CHUNK_MAX_ORDER);
}
_Static_assert(SCX_BUDDY_CHUNK_PAGES * PAGE_SIZE >= SCX_BUDDY_MIN_ALLOC_BYTES * SCX_BUDDY_CHUNK_ITEMS,
"chunk must fit within the stack allocation");
/*
* This reserves a chunk for the chunk metadata, then breaks
* the rest of the full allocation into the different buckets.
* We allocating the memory by grabbing blocks of progressively
* smaller sizes from the allocator, which are guaranteed to be
* continuous.
*
* This operation also populates the allocator.
*/
last_order = SCX_BUDDY_CHUNK_MAX_ORDER;
left = sizeof(*chunk);
cur_idx = 0;
while((power2 = scx_ffs(left)) && can_loop) {
if (unlikely(power2 >= SCX_BUDDY_CHUNK_MAX_ORDER)) {
scx_bpf_error("buddy chunk metadata too large");
return NULL;
}
/* Round up allocations that are too small. */
if (power2 < SCX_BUDDY_MIN_ALLOC_SHIFT) {
order = 0;
left = 0;
} else {
order = power2 - SCX_BUDDY_MIN_ALLOC_SHIFT;
left -= 1 << power2;
}
idx = cur_idx;
bpf_for (ord, order, last_order) {
/* Skip to the buddy. */
idx += 1 << ord;
/* Mark it free. */
chunk->order_indices[ord] = idx;
header_set_order(chunk, idx, ord);
}
/* Adjust the index. */
cur_idx += 1 << order;
}
return chunk;
}
__hidden
int scx_buddy_init(struct scx_buddy *buddy, size_t size)
{
scx_buddy_chunk_t *chunk;
int ret;
/* Set a minimum allocation size. */
if (size < SCX_BUDDY_MIN_ALLOC_BYTES)
return -EINVAL;
/* Check if already initialized. */
if (buddy->min_alloc_bytes)
return -EALREADY;
buddy->min_alloc_bytes = size;
_Static_assert(SCX_BUDDY_CHUNK_PAGES > 0, "chunk must use one or more pages");
/* One allocation per chunk. */
ret = scx_stk_init(&buddy->stack, SCX_BUDDY_CHUNK_PAGES * PAGE_SIZE, SCX_BUDDY_CHUNK_PAGES);
if (ret) {
buddy->min_alloc_bytes = 0;
return ret;
}
chunk = scx_buddy_chunk_get(&buddy->stack);
if (chunk) {
/* Put the chunk at the beginning of the list. */
chunk->next = buddy->first_chunk;
chunk->prev = NULL;
buddy->first_chunk = chunk;
} else {
/* Mark as uninitialized. */
buddy->min_alloc_bytes = 0;
buddy->first_chunk = NULL;
}
return chunk ? 0 : -ENOMEM;
}
__weak
u64 scx_buddy_chunk_alloc(scx_buddy_chunk_t *chunk, int order_req)
{
scx_buddy_header_t *header;
u64 address;
u64 order;
u32 idx;
bpf_for(order, order_req, SCX_BUDDY_CHUNK_MAX_ORDER) {
if (chunk->order_indices[order] != SCX_BUDDY_CHUNK_ITEMS)
break;
}
if (order == SCX_BUDDY_CHUNK_MAX_ORDER)
return (u64)NULL;
idx = chunk->order_indices[order];
header = chunk_get_header(chunk, idx);
chunk->order_indices[order] = header->next_index;
header->prev_index = SCX_BUDDY_CHUNK_ITEMS;
header->next_index = SCX_BUDDY_CHUNK_ITEMS;
header_set_order(chunk, idx, order_req);
address = (u64)chunk_idx_to_mem(chunk, idx);
/* If we allocated from a larger-order chunk, split the buddies. */
bpf_for(order, order_req, order) {
/* Flip the bit for the current order. */
idx ^= 1 << order;
/* Add the buddy of the allocation to the free list. */
header = chunk_get_header(chunk, idx);
header_set_order(chunk, idx, order);
header->prev_index = SCX_BUDDY_CHUNK_ITEMS;
header->next_index = chunk->order_indices[order];
chunk->order_indices[order] = idx;
}
return address;
}
__weak
u64 scx_buddy_alloc_internal(struct scx_buddy *buddy, size_t size)
{
scx_buddy_chunk_t *chunk;
u64 address;
int order;
order = size_to_order(size);
if (order >= SCX_BUDDY_CHUNK_MAX_ORDER - 1) {
scx_bpf_error("Allocation size %lu too large", size);
return (u64)NULL;
}
bpf_spin_lock(&buddy->lock);
chunk = buddy->first_chunk;
do {
address = scx_buddy_chunk_alloc(chunk, order);
chunk = chunk->next;
} while (address == (u64)NULL && can_loop);
bpf_spin_unlock(&buddy->lock);
if (address)
return address;
/* Get a new chunk. */
chunk = scx_buddy_chunk_get(&buddy->stack);
if (!chunk)
return (u64)NULL;
bpf_spin_lock(&buddy->lock);
/* Add the chunk into the allocator and retry. */
chunk->next = buddy->first_chunk;
chunk->prev = NULL;
buddy->first_chunk = chunk;
address = scx_buddy_chunk_alloc(buddy->first_chunk, order);
bpf_spin_unlock(&buddy->lock);
return address;
}
__weak
void scx_buddy_free_internal(struct scx_buddy *buddy, u64 addr)
{
scx_buddy_header_t *header, *buddy_header, *tmp_header;
scx_buddy_chunk_t *chunk, *target_chunk;
u64 idx, buddy_idx;
u8 order;
if (addr & (SCX_BUDDY_MIN_ALLOC_BYTES - 1)) {
scx_bpf_error("Freeing unaligned address %llx", addr);
return;
}
bpf_spin_lock(&buddy->lock);
/* Align to the chunk boundary. */
target_chunk = (void __arena *)(addr & ~SCX_BUDDY_CHUNK_OFFSET_MASK);
/* XXX Only necessary for debugging. */
for (chunk = buddy->first_chunk; chunk != NULL && can_loop; chunk = chunk->next) {
if (chunk == target_chunk)
break;
}
if (chunk == NULL) {
bpf_spin_unlock(&buddy->lock);
scx_bpf_error("could not find chunk for address %llx", addr);
return;
}
/* Get the page idx. */
idx = (addr & SCX_BUDDY_CHUNK_OFFSET_MASK) / SCX_BUDDY_MIN_ALLOC_BYTES;
header = chunk_get_header(chunk, idx);
bpf_for(order, header_get_order(chunk, idx), SCX_BUDDY_CHUNK_MAX_ORDER) {
buddy_idx = idx ^= 1 << order;
buddy_header = chunk_get_header(chunk, buddy_idx);
/* Check if the buddy is not in the free list. */
if (chunk->order_indices[order] != buddy_idx &&
buddy_header->prev_index == SCX_BUDDY_CHUNK_ITEMS &&
buddy_header->next_index == SCX_BUDDY_CHUNK_ITEMS)
break;
/* Pop off the list head if necessary. */
if (chunk->order_indices[order] == buddy_idx)
chunk->order_indices[order] = buddy_header->next_index;
/* Pop */
if (buddy_header->prev_index != SCX_BUDDY_CHUNK_ITEMS) {
tmp_header = chunk_get_header(chunk, buddy_header->prev_index);
tmp_header->next_index = buddy_header->next_index;
buddy_header->next_index = SCX_BUDDY_CHUNK_ITEMS;
}
if (buddy_header->next_index != SCX_BUDDY_CHUNK_ITEMS) {
tmp_header = chunk_get_header(chunk, buddy_header->next_index);
tmp_header->prev_index = buddy_header->prev_index;
buddy_header->prev_index = SCX_BUDDY_CHUNK_ITEMS;
}
header_set_order(chunk, buddy_idx, SCX_BUDDY_CHUNK_MAX_ORDER);
idx = idx < buddy_idx ? idx : buddy_idx;
header = chunk_get_header(chunk, idx);
header_set_order(chunk, idx, order + 1);
}
order = header_get_order(chunk, idx);
header->next_index = chunk->order_indices[order];
chunk->order_indices[order] = idx;
bpf_spin_unlock(&buddy->lock);
}
/**
* scx_userspace_arena_alloc_pages - BPF program to enable allocating arena pages
* explicitly from userspace.
*
* @ctx->sz: Size to allocate. Any positive number is a valid request.
* @ctx->ret: Address of the allocated pages. NULL if unable to allocate.
*/
SEC("syscall")
int scx_userspace_arena_alloc_pages(struct scx_userspace_arena_alloc_pages_args *ctx)
{
u32 pages = (ctx->sz + PAGE_SIZE - 1) / PAGE_SIZE;
ctx->sz = pages * PAGE_SIZE;
ctx->ret = bpf_arena_alloc_pages(&arena, NULL, pages, NUMA_NO_NODE, 0);
return 0;
}
/**
* scx_userspace_arena_free_pages - BPF program to enable freeing arena pages
* explicitly from userspace.
*
* @ctx->addr: Address of the allocated pages. Should have been allocated by
* `scx_userspace_arena_alloc_pages`.
* @ctx->sz: Size to free. Should be the same number passed to
* `scx_userspace_arena_alloc_pages`.
*/
SEC("syscall")
int scx_userspace_arena_free_pages(struct scx_userspace_arena_free_pages_args *ctx)
{
u32 pages = (ctx->sz + PAGE_SIZE - 1) / PAGE_SIZE;
bpf_arena_free_pages(&arena, ctx->addr, pages);
return 0;
}
scx-1.0.12/lib/sdt_task.bpf.c 0000664 0000000 0000000 00000003402 15007705772 0015675 0 ustar 00root root 0000000 0000000 /*
* SPDX-License-Identifier: GPL-2.0
* Copyright (c) 2024 Meta Platforms, Inc. and affiliates.
* Copyright (c) 2024 Tejun Heo
* Copyright (c) 2024 Emil Tsalapatis
*/
#include
#include
/*
* Task BPF map entry recording the task's assigned ID and pointing to the data
* area allocated in arena.
*/
struct scx_task_map_val {
union sdt_id tid;
__u64 tptr;
struct sdt_data __arena *data;
};
struct {
__uint(type, BPF_MAP_TYPE_TASK_STORAGE);
__uint(map_flags, BPF_F_NO_PREALLOC);
__type(key, int);
__type(value, struct scx_task_map_val);
} scx_task_map SEC(".maps");
struct scx_allocator scx_task_allocator;
__hidden
void __arena *scx_task_alloc(struct task_struct *p)
{
struct sdt_data __arena *data = NULL;
struct scx_task_map_val *mval;
mval = bpf_task_storage_get(&scx_task_map, p, 0,
BPF_LOCAL_STORAGE_GET_F_CREATE);
if (!mval)
return NULL;
data = scx_alloc(&scx_task_allocator);
mval->tid = data->tid;
mval->tptr = (__u64) p;
mval->data = data;
return (void __arena *)data->payload;
}
__hidden
int scx_task_init(__u64 data_size)
{
return scx_alloc_init(&scx_task_allocator, data_size);
}
__hidden
void __arena *scx_task_data(struct task_struct *p)
{
struct sdt_data __arena *data;
struct scx_task_map_val *mval;
scx_arena_subprog_init();
mval = bpf_task_storage_get(&scx_task_map, p, 0, 0);
if (!mval)
return NULL;
data = mval->data;
return (void __arena *)data->payload;
}
__hidden
void scx_task_free(struct task_struct *p)
{
struct scx_task_map_val *mval;
scx_arena_subprog_init();
mval = bpf_task_storage_get(&scx_task_map, p, 0, 0);
if (!mval)
return;
scx_alloc_free_idx(&scx_task_allocator, mval->tid.idx);
mval->data = NULL;
mval->tptr = 0;
}
scx-1.0.12/libalpm/ 0000775 0000000 0000000 00000000000 15007705772 0014022 5 ustar 00root root 0000000 0000000 scx-1.0.12/libalpm/openrc/ 0000775 0000000 0000000 00000000000 15007705772 0015310 5 ustar 00root root 0000000 0000000 scx-1.0.12/libalpm/openrc/90-scx-scheds-upgrade.hook 0000664 0000000 0000000 00000000530 15007705772 0022107 0 ustar 00root root 0000000 0000000 [Trigger]
Type = Path
Operation = Upgrade
Target = etc/conf.d/scx
Target = etc/default/scx
Target = etc/init.d/scx
Target = usr/bin/scx_*
[Trigger]
Type = Package
Operation = Upgrade
Target = scx-scheds*
[Action]
Description = Checking scx_scheduler...
When = PostTransaction
Exec = /usr/share/libalpm/scripts/scx-openrc-restart
NeedsTargets
scx-1.0.12/libalpm/openrc/meson.build 0000664 0000000 0000000 00000000524 15007705772 0017453 0 ustar 00root root 0000000 0000000 # Install the 'scx-openrc-restart' file to the '/usr/share/libalpm/scripts' directory
install_data('scx-openrc-restart', install_dir: '/usr/share/libalpm/scripts')
# Install the '90-scx-scheds-upgrade.hook' file to the '/usr/share/libalpm/hooks' directory
install_data('90-scx-scheds-upgrade.hook', install_dir: '/usr/share/libalpm/hooks')
scx-1.0.12/libalpm/openrc/scx-openrc-restart 0000775 0000000 0000000 00000000464 15007705772 0021005 0 ustar 00root root 0000000 0000000 #!/usr/bin/env bash
# SPDX-License-Identifier: GPL-2.0-only
# Check the status of the service
if /etc/init.d/scx status > /dev/null; then
echo "The service is active. Restarting..."
/usr/bin/rc-service scx restart
echo "Service has been restarted."
else
echo "The service is not active."
fi
scx-1.0.12/libalpm/systemd/ 0000775 0000000 0000000 00000000000 15007705772 0015512 5 ustar 00root root 0000000 0000000 scx-1.0.12/libalpm/systemd/90-scx-scheds-upgrade.hook 0000664 0000000 0000000 00000000525 15007705772 0022315 0 ustar 00root root 0000000 0000000 [Trigger]
Type = Path
Operation = Upgrade
Target = etc/default/scx
Target = usr/bin/scx_*
Target = usr/lib/systemd/system/scx.service
[Trigger]
Type = Package
Operation = Upgrade
Target = scx-scheds*
[Action]
Description = Checking scx_scheduler...
When = PostTransaction
Exec = /usr/share/libalpm/scripts/scx-systemd-restart
NeedsTargets
scx-1.0.12/libalpm/systemd/meson.build 0000664 0000000 0000000 00000000526 15007705772 0017657 0 ustar 00root root 0000000 0000000 # Install the 'scx-systemd-restart' file to the '/usr/share/libalpm/scripts' directory
install_data('scx-systemd-restart', install_dir: '/usr/share/libalpm/scripts')
# Install the '90-scx-scheds-upgrade.hook' file to the '/usr/share/libalpm/hooks' directory
install_data('90-scx-scheds-upgrade.hook', install_dir: '/usr/share/libalpm/hooks')
scx-1.0.12/libalpm/systemd/scx-systemd-restart 0000775 0000000 0000000 00000000523 15007705772 0021405 0 ustar 00root root 0000000 0000000 #!/usr/bin/env bash
# SPDX-License-Identifier: GPL-2.0-only
# Check the status of the service
if systemctl is-active --quiet scx.service; then
echo "The service is active. Restarting..."
systemctl daemon-reload
systemctl restart scx.service
echo "Service has been restarted."
else
echo "The service is not active."
fi
scx-1.0.12/meson-scripts/ 0000775 0000000 0000000 00000000000 15007705772 0015210 5 ustar 00root root 0000000 0000000 scx-1.0.12/meson-scripts/bpftool_build_skel 0000775 0000000 0000000 00000000642 15007705772 0021002 0 ustar 00root root 0000000 0000000 #!/bin/bash
set -e
bpftool="$1"
input="$2"
skel="$3"
subskel="$4"
stem="${input%.o}"
name="${input%.bpf.o}"
name="${name##*/}"
"$bpftool" gen object "$stem".l1o "$input"
"$bpftool" gen object "$stem".l2o "$stem".l1o
"$bpftool" gen object "$stem".l3o "$stem".l2o
cmp "$stem".l2o "$stem".l3o
"$bpftool" gen skeleton "$stem".l3o name "$name" > "$skel"
"$bpftool" gen subskeleton "$stem".l3o name "$name" > "$subskel"
scx-1.0.12/meson-scripts/bpftool_build_skel_lib 0000775 0000000 0000000 00000001051 15007705772 0021623 0 ustar 00root root 0000000 0000000 #!/bin/bash
set -e
bpftool="$1"
input="$2"
skel="$3"
subskel="$4"
lib="$5"
stem="${input%.o}"
name="${input%.bpf.o}"
name="${name##*/}"
if [ -z "$lib" ] || [ `basename $lib` == $name ];
then
"$bpftool" gen object "$stem".l1o "$input"
else
"$bpftool" gen object "$stem".l1o "$input" "$lib".bpf.o
"$bpftool" gen object "$stem".l2o "$stem".l1o
"$bpftool" gen object "$stem".l3o "$stem".l2o
cmp "$stem".l2o "$stem".l3o
"$bpftool" gen skeleton "$stem".l3o name "$name" > "$skel"
"$bpftool" gen subskeleton "$stem".l3o name "$name" > "$subskel"
fi
scx-1.0.12/meson-scripts/bpftool_dummy.c 0000664 0000000 0000000 00000000127 15007705772 0020234 0 ustar 00root root 0000000 0000000 // This is just used as a dummy target file for meson
int main(void) {
return 0;
}
scx-1.0.12/meson-scripts/build_bpftool 0000664 0000000 0000000 00000001331 15007705772 0017755 0 ustar 00root root 0000000 0000000 #!/bin/bash
set -e
out=$("$1" 'map(select(.["file"] | contains ("cc_cflags_probe.c"))) | first | .["command"]' < compile_commands.json)
out=${out#\"}
out=${out%\"}
args=($out)
idx=0
cc=${args[idx]}
if [ "$cc" = "ccache" -o "$cc" = "sccache" ]; then
idx=$((idx+1))
cc="$cc ${args[idx]}"
fi
declare -a cflags=()
for arg in ${args[@]:(idx+1)}; do
case $arg in
-I*|-M*|-o|-c) ;;
-*) cflags+="$arg ";;
esac
done
extra_args=()
# When using clang, `LLVM=1` needs to be passed as an argument. Otherwise some
# parts of the build system will attempt to invoke GCC.
if cc --version 2>&1 | grep clang; then
extra_args+="LLVM=1"
fi
cd $3
make_out=$(env CC="$cc" CFLAGS="$cflags" "$2" -j"$4" $extra_args)
exit $?
scx-1.0.12/meson-scripts/build_libbpf 0000775 0000000 0000000 00000001365 15007705772 0017560 0 ustar 00root root 0000000 0000000 #!/bin/bash
set -e
out=$("$1" 'map(select(.["file"] | contains ("cc_cflags_probe.c"))) | first | .["command"]' < compile_commands.json)
out=${out#\"}
out=${out%\"}
args=($out)
idx=0
cc=${args[idx]}
if [ "$cc" = "ccache" ]; then
idx=$((idx+1))
cc="$cc ${args[idx]}"
fi
if [ "$cc" = "sccache" ]; then
idx=$((idx+1))
cc="$cc ${args[idx]}"
fi
if [ "$cc" = "ccache" ]; then
idx=$((idx+1))
cc="$cc ${args[idx]}"
fi
if [ "$cc" = "sccache" ]; then
idx=$((idx+1))
cc="$cc ${args[idx]}"
fi
declare -a cflags=()
for arg in ${args[@]:(idx+1)}; do
case $arg in
-I*|-M*|-o|-c) ;;
-*) cflags+="$arg ";;
esac
done
make_out=$(env CC="$cc" CFLAGS="$cflags" BUILD_STATIC_ONLY=y DESTDIR=. "$2" install -C "$3" -j"$4")
exit $?
scx-1.0.12/meson-scripts/cargo_fetch 0000775 0000000 0000000 00000000716 15007705772 0017406 0 ustar 00root root 0000000 0000000 #!/bin/bash
shopt -s globstar
set -e
cargo="$1"
#
# Run `cargo fetch` for each Cargo.toml found in the source directory. This
# can lead to fetching unnecessary packages if the source directory contains
# past cargo build artifacts. While not ideal, this is a lot simpler and
# shouldn't cause problems in practice.
#
for manifest in ${MESON_SOURCE_ROOT}/**/Cargo.toml; do
echo "Fetching for $manifest"
"$cargo" fetch --manifest-path="$manifest"
done
scx-1.0.12/meson-scripts/cc_cflags_probe.c 0000664 0000000 0000000 00000000215 15007705772 0020445 0 ustar 00root root 0000000 0000000 // This exists only to get the same compiler and flags meson uses.
// See build_libbpf script for more info
int main(void) {
return 0;
}
scx-1.0.12/meson-scripts/compile_scx_lib 0000775 0000000 0000000 00000000252 15007705772 0020270 0 ustar 00root root 0000000 0000000 #!/bin/bash
set -e
bpftool="$1"
output="$2"
lib="$3"
dir="$PWD/lib"
libs=`find $dir -type f -name *.bpf.o | grep -v $lib.bpf.o`
${bpftool} gen object "$output" $libs
scx-1.0.12/meson-scripts/fetch_bpftool 0000664 0000000 0000000 00000000412 15007705772 0017746 0 ustar 00root root 0000000 0000000 #!/bin/bash
URL=https://github.com/libbpf/bpftool.git
cd $1
rm -rf bpftool
git clone --depth=1 ${URL}
cd bpftool
git fetch --depth=1 origin $2 || {
echo "commit $2 does not exists in ${URL}"
exit 1
}
git checkout $2
git submodule update --init --recursive
scx-1.0.12/meson-scripts/fetch_libbpf 0000664 0000000 0000000 00000000562 15007705772 0017545 0 ustar 00root root 0000000 0000000 #!/bin/bash
URL=https://github.com/libbpf/libbpf.git
unset CDPATH
cd $1
rm -rf libbpf
git clone --depth=1 ${URL}
cd libbpf
git fetch --depth=1 origin $2 || {
echo "commit $2 does not exists in ${URL}"
exit 1
}
git checkout $2
# This is needed because we haven't built libbpf yet
# and this is where the headers will end up
mkdir src/usr
mkdir src/usr/include
scx-1.0.12/meson-scripts/get_bpftool_ver 0000775 0000000 0000000 00000000123 15007705772 0020312 0 ustar 00root root 0000000 0000000 #!/bin/bash
"$1" --version | sed -nr 's/^.*bpftool v([\.0-9]*)(git)?( .*)?$/\1/p'
scx-1.0.12/meson-scripts/get_clang_ver 0000775 0000000 0000000 00000000147 15007705772 0017737 0 ustar 00root root 0000000 0000000 #!/bin/bash
"$1" --version | sed -nr 's/^.*clang version ([\.0-9]*)(git)?(-rc.*)?(\+.*)?( .*)?$/\1/p'
scx-1.0.12/meson-scripts/get_sys_incls 0000775 0000000 0000000 00000001200 15007705772 0017774 0 ustar 00root root 0000000 0000000 #!/bin/bash
set -e
clang="$1"
#
# Get Clang's default includes on this system, as opposed to those seen by
# '-target bpf'. This fixes "missing" files on some architectures/distros,
# such as asm/byteorder.h, asm/socket.h, asm/sockios.h, sys/cdefs.h etc.
#
# Use '-idirafter': Don't interfere with include mechanics except where the
# build would have failed anyways.
#
"$clang" -v -E - < /dev/null 2>&1 \
| sed -n '/<...> search starts here:/,/End of search list./{ s| \(/.*\)|-idirafter \1|p }' \
"$clang" -dM -E - < /dev/null \
| grep '__riscv_xlen ' \
| awk '{printf("-D__riscv_xlen=%d -D__BITS_PER_LONG=%d", $3, $3)}'
scx-1.0.12/meson-scripts/install_rust_user_scheds 0000775 0000000 0000000 00000004720 15007705772 0022253 0 ustar 00root root 0000000 0000000 #!/bin/bash
set -e
for manifest in "$MESON_SOURCE_ROOT"/scheds/rust/*/Cargo.toml; do
source_dir="${manifest%/Cargo.toml}"
target_dir="${MESON_BUILD_ROOT}"
name="${source_dir##*/}"
# Skip scx_mitosis and scx_wd40
if [ "$name" = "scx_mitosis" ] || [ "$name" = "scx_wd40" ]; then
echo "Skipping installation of $name"
continue
fi
bins=($(ls -t "${target_dir}/"*"/${name}"))
if [ ${#bins[@]} -lt 1 ]; then
echo "Cannot find a binary for $name under $target_dir" 1>&2
exit 1
fi
# XXX - Can we detect the current buildtype and install the correct one?
if [ ${#bins[@]} -gt 1 ]; then
echo "Found multiple binaries for $name under $target_dir, installing the latest which may not be what you want" 1>&2
fi
install -D "${bins[0]}" "${DESTDIR}/${MESON_INSTALL_PREFIX}/bin/${name}"
done
for manifest in "$MESON_SOURCE_ROOT"/rust/*/Cargo.toml; do
source_dir="${manifest%/Cargo.toml}"
target_dir="${MESON_BUILD_ROOT}"
name="${source_dir##*/}"
if [ ! -f "${target_dir}/"*"/${name}" ]; then
continue
fi
bins=($(ls -t "${target_dir}/"*"/${name}"))
if [ ${#bins[@]} -lt 1 ]; then
echo "Skipping. Cannot find a binary for $name under $target_dir" 1>&2
continue
fi
# XXX - Can we detect the current buildtype and install the correct one?
if [ ${#bins[@]} -gt 1 ]; then
echo "Found multiple binaries for $name under $target_dir, installing the latest which may not be what you want" 1>&2
fi
# Install bus spec for scx_loader
if [ "$name" = "scx_loader" ]; then
install -D -m 0644 "${source_dir}/org.scx.Loader.conf" "${DESTDIR}/usr/share/dbus-1/system.d/org.scx.Loader.conf"
fi
install -D "${bins[0]}" "${DESTDIR}/${MESON_INSTALL_PREFIX}/bin/${name}"
done
for manifest in "$MESON_SOURCE_ROOT"/tools/*/Cargo.toml; do
source_dir="${manifest%/Cargo.toml}"
target_dir="${MESON_BUILD_ROOT}"
name="${source_dir##*/}"
bins=($(ls -t "${target_dir}/"*"/${name}"))
if [ ${#bins[@]} -lt 1 ]; then
echo "Cannot find a binary for $name under $target_dir" 1>&2
exit 1
fi
# XXX - Can we detect the current buildtype and install the correct one?
if [ ${#bins[@]} -gt 1 ]; then
echo "Found multiple binaries for $name under $target_dir, installing the latest which may not be what you want" 1>&2
fi
install -D "${bins[0]}" "${DESTDIR}/${MESON_INSTALL_PREFIX}/bin/${name}"
done
scx-1.0.12/meson-scripts/run_stress_tests 0000775 0000000 0000000 00000012350 15007705772 0020570 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python3
"""
Small wrapper for running stress tests. Do not make this more complicated and
assume any libraries besides Python3 stdlib.
"""
import logging
import os
import subprocess
import sys
import time
from pathlib import PurePath
from typing import List
from argparse import ArgumentParser, Namespace
from configparser import ConfigParser
logger = logging.getLogger(__name__)
SCRIPT_DIR: str = os.path.dirname(os.path.realpath(__file__))
def get_exe_path(exe: str) -> str:
path = subprocess.check_output(["which", exe])
return path.decode("utf-8").replace("\n", "")
def sched_path(path: str, sched: str) -> str:
rel_path = subprocess.check_output(
["find", path, "-type", "f", "-executable", "-name", sched]).decode("utf-8").replace("\n", "")
full_path = subprocess.check_output(["readlink", "-f", rel_path]).decode("utf-8").replace("\n", "")
logger.debug(f"found scheduler {sched} in path: {full_path}")
return full_path
def load_config(path: str) -> ConfigParser:
config = ConfigParser()
config.read(path)
return config
def run_stress_test(
config,
build_dir: str,
output: str,
vng_path: str,
kernel: str,
verbose: bool,
rw: bool,
headers: str,
extra_scheduler_args: str,
) -> int:
scheduler_args = config.get('scheduler_args')
stress_cmd = config.get('stress_cmd')
s_path = sched_path(build_dir, config.get('sched'))
sched_cmd = s_path + " " + config.get('sched_args')
if extra_scheduler_args:
sched_cmd = sched_cmd + " " + extra_scheduler_args
timeout_sec = int(config.get("timeout_sec"))
if vng_path:
cmd = [vng_path, "-m", "10G", "--cpus", "10", "--user", "root", "-v", "-r", kernel]
if config.get("qemu_opts"):
cmd += ['--qemu-opts']
cmd += [f"'{config.get("qemu_opts")}'"]
vm_input = f"{stress_cmd} & timeout --foreground --preserve-status {timeout_sec} {sched_cmd}"
if bpftrace_scripts := config.get('bpftrace_scripts'):
vm_input = f"\"{build_dir}/bpftrace_stress_wrapper.sh\" '{stress_cmd}' '{sched_cmd}' '{timeout_sec}' '{bpftrace_scripts}'"
if headers:
vm_input += f" '{headers}'"
if rw and os.getenv('CI'):
print('mounting VNG as RW because CI')
cmd += ["--rw"]
elif rw:
print('not mounting VNG as RW because not CI')
cmd += ["--"]
cmd += [vm_input]
err = sys.stderr if output == "-" else open(output, "w")
out = sys.stdout if output == "-" else err
print(f"vng cmd is {cmd}")
proc = subprocess.Popen(
cmd, env=os.environ, shell=False, stdout=out,
stderr=err, stdin=subprocess.PIPE, text=True)
proc.wait()
return proc.returncode
def stress_tests(args: Namespace) -> None:
configs = load_config(args.config)
vng_path = ""
if args.vng:
try:
vng_path = get_exe_path("vng")
except Exception:
raise OSError(
"Please install `vng` to run, see:\n"
"https://github.com/arighi/virtme-ng?tab=readme-ov-file#installation")
return_codes = {}
for test_name in configs.sections():
if args.stress_test and test_name != args.stress_test:
continue
if args.sched and configs[test_name].get('sched') != args.sched:
continue
print(f"Running stress test: {test_name}")
return_codes[test_name] = run_stress_test(
configs[test_name],
args.build_dir,
args.output,
vng_path,
args.kernel,
args.verbose,
args.rw,
args.headers,
args.extra_scheduler_args,
)
for test_name, ret in return_codes.items():
if ret not in (143, 0):
logging.error(f"Failed stress tests for {test_name}: exit {ret}")
sys.exit(ret)
logging.info("All stress tests passed!")
if __name__ == "__main__":
parser = ArgumentParser(prog=__file__)
parser.add_argument(
'-c', '--config',
default=os.path.join(SCRIPT_DIR, "stress_tests.ini"),
help='Path to config file'
)
parser.add_argument('-o', '--output', default='-', help='Scheduler output')
parser.add_argument(
'-t', '--stress-test', default='', help='Name of the stress test (default: all)')
parser.add_argument(
'-b', '--build-dir', default='build', help='Meson build dir')
parser.add_argument(
'-k', '--kernel', default='', help='Kernel path for vng')
parser.add_argument(
'-v', '--verbose', action='store_true', help='Verbose output')
parser.add_argument(
'--vng', action='store_true', default=True, help='Run in vng')
parser.add_argument(
'--sched', default='', help='Scheduler to test (default: all)'
)
parser.add_argument(
'--rw', default=False, help='Mount VNG Directories as RW (dangerous)'
)
parser.add_argument(
'--headers', default='', help='Kernel Headers Path'
)
parser.add_argument(
'--extra-scheduler-args', default='', help='a quoted string of extra scheduler args'
)
args = parser.parse_args()
if args.verbose:
logger.setLevel(logging.DEBUG)
stress_tests(args)
scx-1.0.12/meson-scripts/stress_tests.ini 0000664 0000000 0000000 00000003201 15007705772 0020452 0 ustar 00root root 0000000 0000000 [scx_lavd]
sched: scx_lavd
sched_args: -v
stress_cmd: stress-ng -t 31 --aggressive -M -c `nproc` -f `nproc` --affinity 1 --affinity-delay 1 --affinity-pin
timeout_sec: 45
[scx_rusty]
sched: scx_rusty
sched_args: -v
stress_cmd: stress-ng -t 31 --aggressive -M -c `nproc` -f `nproc` --affinity 1 --affinity-delay 1 --affinity-pin
timeout_sec: 45
[scx_rustland]
sched: scx_rustland
sched_args: -v
stress_cmd: stress-ng -t 31 --aggressive -M -c `nproc` -f `nproc` --affinity 1 --affinity-delay 1 --affinity-pin
timeout_sec: 45
[scx_bpfland]
sched: scx_bpfland
sched_args: -v
stress_cmd: stress-ng -t 31 --aggressive -M -c `nproc` -f `nproc` --affinity 1 --affinity-delay 1 --affinity-pin
timeout_sec: 45
[scx_flash]
sched: scx_flash
sched_args:
stress_cmd: stress-ng -t 31 --aggressive -M -c `nproc` -f `nproc` --affinity 1 --affinity-delay 1 --affinity-pin
timeout_sec: 45
[scx_layered]
sched: scx_layered
sched_args: --run-example -v --stats 1 --enable-gpu-support
stress_cmd: stress-ng -t 31 --aggressive -M -c `nproc` -f `nproc` --affinity 1 --affinity-delay 1 --affinity-pin
timeout_sec: 45
bpftrace_scripts: dsq_lat.bt,process_runqlat.bt
[scx_p2dq]
sched: scx_p2dq
sched_args:
stress_cmd: stress-ng -t 31 --aggressive -M -c `nproc` -f `nproc` --affinity 1 --affinity-delay 1 --affinity-pin
timeout_sec: 45
[scx_chaos]
sched: scx_chaos
sched_args:
stress_cmd: stress-ng -t 31 --aggressive -M -c `nproc` -f `nproc` --affinity 1 --affinity-delay 1 --affinity-pin
timeout_sec: 45
[scx_tickless]
sched: scx_tickless
sched_args: -v
stress_cmd: stress-ng -t 31 --aggressive -M -c `nproc` -f `nproc` --affinity 1 --affinity-delay 1 --affinity-pin
timeout_sec: 45
scx-1.0.12/meson-scripts/test_sched 0000775 0000000 0000000 00000004570 15007705772 0017271 0 ustar 00root root 0000000 0000000 #!/bin/bash
#
# Run a scheduler for TIMEOUT seconds inside virtme-ng and catch potential
# errors, then unload the scheduler and return the exit status.
# Maximum time for each scheduler run.
TEST_TIMEOUT=30
# Maximum timeout for the guest used for each scheduler run (this is used to
# hard-shutdown the guest in case of system hangs).
GUEST_TIMEOUT=60
# List of schedulers to test
#
# TODO:
# - scx_mitosis: not ready yet
#
declare -A SCHEDS
VNG_RW=''
# Enable vng rw for when on ci.
if [ $# -ge 3 ] ; then
if [ "$3" == "VNG_RW=true" ]; then
echo 'setting vng to mount rw'
VNG_RW=' --rw '
fi
fi
# enable running tests on individual schedulers
if [ $# -ge 2 ] ; then
SCHEDS[$2]="-v"
else
SCHEDS["scx_simple"]="-v"
SCHEDS["scx_central"]="-v"
SCHEDS["scx_nest"]="-v"
SCHEDS["scx_flatcg"]="-v"
SCHEDS["scx_pair"]="-v"
SCHEDS["scx_rusty"]="-v"
SCHEDS["scx_p2dq"]="-v"
SCHEDS["scx_rustland"]="-v"
SCHEDS["scx_bpfland"]="-v"
SCHEDS["scx_layered"]="-v --run-example"
fi
if [[ -v SCHEDS["scx_layered"] ]] ; then
SCHEDS["scx_layered"]="--run-example -v --stats 1"
fi
printf "testing scheds:\n"
for i in "${!SCHEDS[@]}"; do
printf "%s=%s\n" "$i" "${SCHEDS[$i]}";
done
if [ ! -x `which vng` ]; then
echo "vng not found, please install virtme-ng to enable testing"
exit 1
fi
if [ $# -lt 1 ]; then
echo "Usage: $0 VMLINUZ"
exit 1
fi
kernel=$1
for sched in ${!SCHEDS[@]}; do
args=${SCHEDS[$sched]}
sched_path=$(find -type f -executable -name ${sched})
if [ ! -n "${sched_path}" ]; then
echo "${sched}: binary not found"
echo "FAIL: ${sched}"
exit 1
fi
echo "testing ${sched_path}"
rm -f /tmp/output
timeout --preserve-status ${GUEST_TIMEOUT} \
vng --user root -m 10G --cpu 8 $VNG_RW -v -r ${kernel} -- \
"timeout --foreground --preserve-status ${TEST_TIMEOUT} ${sched_path} ${args}" \
2> >(tee /tmp/output) &1 | tee veristat.ci.log
exit $?
else
sudo veristat ${BPF_PATH} 2>&1 | tee veristat.ci.log
exit $?
fi
fi
for BPF_PATH in $(find ${BUILD_DIR} -type f -name bpf.bpf.o); do
if [ -n "${KERNEL}" ]; then
timeout --preserve-status ${GUEST_TIMEOUT} \
vng --user root -m 10G --cpu 8 $VNG_RW -v --user root -r ${KERNEL} -- \
sudo veristat ${BPF_PATH} 2>&1 | tee "$(basename "${BPF_PATH}")-veristat.ci.log"
else
echo "$BPF_PATH"
sudo veristat ${BPF_PATH} 2>&1 | tee "$(basename "${BPF_PATH}")-veristat.ci.log"
fi
done
scx-1.0.12/meson-scripts/veristat_diff 0000775 0000000 0000000 00000004434 15007705772 0017774 0 ustar 00root root 0000000 0000000 #!/usr/bin/env bash
GUEST_TIMEOUT=25
BUILD_DIR=$1
SCHED=$2
KERNEL=$3
DIFF_DIR=$4
if [ "${KERNEL}" == "vmlinuz" ]; then
unset KERNEL
fi
cd $build_dir
if [ -n "${KERNEL}" ] && [ ! -x `which vng` ]; then
echo "vng not found, please install virtme-ng to enable testing"
exit 1
fi
if [ -n "${SCHED}" ]; then
BPF_PATH=$(find ${BUILD_DIR} -type f -name bpf.bpf.o | grep ${SCHED})
echo "Running veristat on ${BPF_PATH}"
if [ -n "${KERNEL}" ]; then
timeout --preserve-status ${GUEST_TIMEOUT} \
vng -m 2G -v --rwdir "${DIFF_DIR}" --user root -r ${KERNEL} -- \
veristat ${BPF_PATH} -o csv > "${DIFF_DIR}/${SCHED}_new.csv" \
|| echo "failed to verify ${SCHED}: ${BPF_PATH}"
if [ -n "${DIFF_DIR}" ]; then
timeout --preserve-status ${GUEST_TIMEOUT} \
vng -m 2G -v --rwdir "${DIFF_DIR}" --user root -r ${KERNEL} -- \
veristat -C "${DIFF_DIR}/${SCHED}_new.csv" "${DIFF_DIR}/${SCHED}.csv" \
-e file,prog,verdict,insns \
|| echo "failed to compare ${SCHED}: ${BPF_PATH}"
fi
exit $?
else
echo "saving veristat diff for ${SCHED}.csv"
sudo veristat ${BPF_PATH} -o csv > "${SCHED}.csv"
if [ -n "${DIFF_DIR}" ]; then
sudo veristat -C "${SCHED}.csv" "${DIFF_DIR}/${SCHED}.csv" \
-e file,prog,verdict,insns
fi
exit $?
fi
fi
for BPF_PATH in $(find ${BUILD_DIR} -type f -name bpf.bpf.o); do
SCHED=$(echo "${BPF_PATH}" | sed 's/.*\/rust\///g' | sed 's/\/.*//g')
if [ -n "${KERNEL}" ]; then
timeout --preserve-status ${GUEST_TIMEOUT} \
vng -m 2G -v --rwdir "${DIFF_DIR}" --user root -r ${KERNEL} -- \
veristat ${BPF_PATH} -o csv > "${DIFF_DIR}/${SCHED}_new.csv" \
|| echo "failed to verify ${SCHED}: ${BPF_PATH}"
if [ -n "${DIFF_DIR}" ]; then
timeout --preserve-status ${GUEST_TIMEOUT} \
vng -m 2G -v --rwdir "${DIFF_DIR}" --user root -r ${KERNEL} -- \
veristat -C "${SCHED}_new.csv" "${DIFF_DIR}/${SCHED}.csv" \
-e file,prog,verdict,insns \
|| echo "failed to compare ${SCHED}: ${BPF_PATH}"
fi
else
echo "saving veristat diff for ${SCHED}.csv"
sudo veristat ${BPF_PATH} -o csv > "${SCHED}.csv"
if [ -n "${DIFF_DIR}" ]; then
sudo veristat -C "${SCHED}.csv" "${DIFF_DIR}/${SCHED}.csv" \
-e file,prog,verdict,insns
fi
fi
done
scx-1.0.12/meson.build 0000664 0000000 0000000 00000044513 15007705772 0014553 0 ustar 00root root 0000000 0000000 project('sched_ext schedulers', 'c',
version: '1.0.12',
license: 'GPL-2.0',
meson_version : '>= 1.2.0',)
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')
build_outside_src = get_option('build_outside_src')
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'))
bpftool_build_skel_lib = find_program(join_paths(meson.current_source_dir(),
'meson-scripts/bpftool_build_skel_lib'))
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'))
scx_lib_name = 'lib'
scx_lib_path = join_paths(meson.current_build_dir(), 'lib/', scx_lib_name)
compile_scx_lib = find_program(join_paths(meson.current_source_dir(),
'meson-scripts/compile_scx_lib'))
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')
protoc = find_program('protoc', required: true)
seccomp = dependency('libseccomp', required: true)
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]
if not build_outside_src
libbpf_local_h += ['.@0@/libbpf'.format(local_build_path) + path]
else
libbpf_local_h += ['@0@/libbpf'.format(local_build_path) + path]
endif
endforeach
message('Fetching libbpf repo')
libbpf_commit = 'c5f22aca0f3aa855daa159b2777472b35e721804'
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 = '183e7010387d1fc9f08051426e9a9fbd5f8d409e'
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 < 5)
error('bpftool >= 7.5 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',
'riscv64gc': '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
# BPF compilation uses the gen_bpf_o generator. The following should be
# passed in as extra_args.
bpf_includes = ['-I', join_paths(meson.current_source_dir(), 'scheds/include'),
'-I', join_paths(meson.current_source_dir(), 'scheds/include/arch/' + arch_dict[cpu]),
'-I', join_paths(meson.current_source_dir(), 'scheds/include/bpf-compat'),
'-I', join_paths(meson.current_source_dir(), 'scheds/include/lib'),]
lib_objs = []
subdir('lib')
#
# 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, bpf_includes,
'-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@'])
gen_bpf_skel_lib = generator(bpftool_build_skel_lib,
output: ['@BASENAME@.skel.h','@BASENAME@.subskel.h' ],
depends: [libbpf, bpftool_target, scx_lib],
arguments: [bpftool_exe_path, '@INPUT@', '@OUTPUT0@', '@OUTPUT1@', scx_lib_path])
#
# 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 meson.is_cross_build()
cargo_target = host_machine.cpu_family() + '-unknown-' + host_machine.kernel() + '-gnu'
cargo_build_args += ['--target', cargo_target]
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_flash', 'scx_rusty', 'scx_p2dq',
'scx_layered', 'scx_mitosis', 'scx_tickless', 'scx_chaos']
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])
run_target('veristat', command: [run_veristat, meson.current_build_dir(),
get_option('veristat_scheduler'), get_option('kernel')])
if get_option('vng_rw_mount') == true
foreach s : rust_scheds
run_target('test_sched_'+s, command: [test_sched, kernel, s, 'VNG_RW=true'])
run_target('veristat_'+s, command: [run_veristat, meson.current_build_dir(),
get_option('veristat_scheduler'), get_option('kernel'), s, 'VNG_RW=true'])
endforeach
else
foreach s : rust_scheds
run_target('test_sched_'+s, command: [test_sched, kernel, s])
run_target('veristat_'+s, command: [run_veristat, meson.current_build_dir(),
get_option('veristat_scheduler'), get_option('kernel'), s])
endforeach
endif
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
# not sure there's a better way
# only different...
copys = [
custom_target('copy stress wrapper',
input : 'scripts/bpftrace_stress_wrapper.sh',
output : 'bpftrace_stress_wrapper.sh',
command : ['cp', '-a', '@INPUT@', '@OUTPUT@'],
install : false,
build_by_default : true),
custom_target('copy dsq_lat',
input : 'scripts/dsq_lat.bt',
output : 'dsq_lat.bt',
command : ['cp', '-a', '@INPUT@', '@OUTPUT@'],
install : false,
build_by_default : true),
custom_target('copy runq_lat',
input : 'scripts/process_runqlat.bt',
output : 'process_runqlat.bt',
command : ['cp', '-a', '@INPUT@', '@OUTPUT@'],
install : false,
build_by_default : true)
]
run_target('stress_tests', command: [run_stress_tests, '-k', kernel, '-b',
meson.current_build_dir()], depends: [copys])
if get_option('vng_rw_mount') == true
foreach s : rust_scheds
if get_option('kernel_headers') == ''
run_target('stress_tests_'+s, command: [run_stress_tests, '-k', kernel,
'-b', meson.current_build_dir(), '--sched', s,
'--rw', 'true',
'--extra-scheduler-args', get_option('extra_sched_args')],
depends: [copys])
else
run_target('stress_tests_'+s, command: [run_stress_tests, '-k', kernel,
'-b', meson.current_build_dir(), '--sched', s,
'--rw', 'true',
'--headers', get_option('kernel_headers'),
'--extra-scheduler-args', get_option('extra_sched_args')],
depends: [copys])
endif
endforeach
else
foreach s : rust_scheds
if get_option('kernel_headers') == ''
run_target('stress_tests_'+s, command: [run_stress_tests, '-k', kernel,
'-b', meson.current_build_dir(), '--sched', s,
'--extra-scheduler-args', get_option('extra_sched_args')],
depends: [copys])
else
run_target('stress_tests_'+s, command: [run_stress_tests, '-k', kernel,
'-b', meson.current_build_dir(), '--sched', s,
'--headers', get_option('kernel_headers'),
'--extra-scheduler-args', get_option('extra_sched_args')],
depends: [copys])
endif
endforeach
endif
endif
thread_dep = dependency('threads')
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
scx-1.0.12/meson.options 0000664 0000000 0000000 00000004622 15007705772 0015144 0 ustar 00root root 0000000 0000000 option('bpf_clang', type: 'string', value: 'clang',
description: 'clang to use when compiling .bpf.c')
option('bpftool', type: 'string',
description: 'bpftool to use when generating .bpf.skel.h. By default, bpftool is automatically downloaded and built during setup. To use an existing bpftool binary, point this to the bpftool path or set it to "disabled" to have meson try to find it automatically')
option('libbpf_a', type: 'string',
description: 'By default, libbpf is automatically downloaded and built during setup. To use an existing static library, point this to the libbpf.a file or set it to "disabled" to use dynamic linking')
option('libbpf_h', type: 'array',
description: 'libbpf header directories, only meaningful with libbpf_a option')
option('cargo', type: 'string', value: 'cargo',
description: 'cargo to use when building rust sub-projects')
option('cargo_home', type: 'string',
description: 'CARGO_HOME env to use when invoking cargo')
option('offline', type: 'boolean', value: false,
description: 'Compilation step should not access the internet')
option('enable_rust', type: 'boolean', value: true,
description: 'Enable rust sub-projects')
option('enable_stress', type: 'boolean', value: true,
description: 'Enable stress tests')
option('kernel', type: 'string', value: 'vmlinuz',
description: 'kernel image used to test schedulers')
option('veristat_scheduler', type: 'string', value: '',
description: 'veristat scheduler to test')
option('veristat_diff_dir', type: 'string', value: '',
description: 'veristat diff dir')
option('kernel_headers', type: 'string', value: '',
description: 'kernel headers to build the schedulers')
option(
'systemd',
type: 'feature',
value: 'auto',
description: 'sd-notify support via libsystemd and install systemd unit files'
)
option(
'openrc',
type: 'feature',
value: 'auto',
description: 'openrc init.d service file'
)
option(
'libalpm',
type: 'feature',
value: 'auto',
description: 'install pacman hooks'
)
option(
'build_outside_src',
type: 'boolean',
value: false,
description: 'enable build cmds to work outside of src dir',
)
option(
'vng_rw_mount',
type: 'boolean',
value: false,
description: 'make vng builds mount rw (for log upload)',
)
option(
'extra_sched_args',
type: 'string',
value: '',
description: 'extra sched args for stress tests',
)
scx-1.0.12/pgo-lto.sh 0000775 0000000 0000000 00000001336 15007705772 0014325 0 ustar 00root root 0000000 0000000 #!/usr/bin/env bash
set -eou pipefail
PGO_TMPDIR=${1:-/tmp/pgo-data}
SCHED=${2:-scx_rustland}
PGO_DUR=${3:-30}
rm -rf "$PGO_TMPDIR"
mkdir -p "$PGO_TMPDIR"
RUSTFLAGS="-C profile-generate=$PGO_TMPDIR -C link-arg=-lgcov" \
cargo build --release --bin "$SCHED"
echo "Running sched to generate PGO"
for i in {0..3}; do
sudo "./target/release/$SCHED" &
sleep "$PGO_DUR"
sudo kill -9 $! || echo "$SCHED already dead"
sleep 1
done
# Merge the `.profraw` files into a `.profdata` file
llvm-profdata merge --failure-mode=warn \
-o "$PGO_TMPDIR/merged.profdata" \
"$PGO_TMPDIR"
# Use the `.profdata` file for guiding optimizations
RUSTFLAGS="-Cprofile-use=$PGO_TMPDIR/merged.profdata" \
cargo build --release --bin "$SCHED"
scx-1.0.12/rust-toolchain.toml 0000664 0000000 0000000 00000000037 15007705772 0016252 0 ustar 00root root 0000000 0000000 [toolchain]
channel = "stable"
scx-1.0.12/rust/ 0000775 0000000 0000000 00000000000 15007705772 0013377 5 ustar 00root root 0000000 0000000 scx-1.0.12/rust/.gitignore 0000664 0000000 0000000 00000000007 15007705772 0015364 0 ustar 00root root 0000000 0000000 target
scx-1.0.12/rust/scx_loader/ 0000775 0000000 0000000 00000000000 15007705772 0015522 5 ustar 00root root 0000000 0000000 scx-1.0.12/rust/scx_loader/Cargo.toml 0000664 0000000 0000000 00000001644 15007705772 0017457 0 ustar 00root root 0000000 0000000 [package]
name = "scx_loader"
version = "1.0.12"
authors = ["Vladislav Nepogodin "]
edition = "2021"
description = "DBUS on-demand loader of sched-ext schedulers"
license = "GPL-2.0-only"
[dependencies]
anyhow = "1.0.65"
clap = { version = "4.5.28", features = ["derive", "env", "unicode", "wrap_help"] }
colored = "3.0.0"
ctrlc = { version = "3.1", features = ["termination"] }
log = "0.4.17"
nix = { features = ["process", "signal"], default-features = false, version = "0.29" }
serde = { version = "1.0.215", features = ["derive"] }
sysinfo = "0.33.1"
tokio = { version = "1.42.0", features = ["macros", "sync", "rt-multi-thread", "process"] }
tokio-util = "0.7.13"
toml = "0.8.19"
zbus = { version = "5.3.1", features = ["tokio"], default-features = false }
zvariant = "5.1"
[lib]
path = "src/lib.rs"
[[bin]]
name = "scx_loader"
path = "src/main.rs"
[lints.clippy]
not_unsafe_ptr_arg_deref = "allow"
scx-1.0.12/rust/scx_loader/LICENSE 0000777 0000000 0000000 00000000000 15007705772 0020155 2../../LICENSE ustar 00root root 0000000 0000000 scx-1.0.12/rust/scx_loader/README.md 0000664 0000000 0000000 00000012511 15007705772 0017001 0 ustar 00root root 0000000 0000000 # scx_loader: A DBUS Interface for Managing sched-ext Schedulers
`scx_loader` is a utility that provides a convenient DBUS interface for starting, stopping, and managing sched_ext schedulers.
## Features
* **`StartScheduler` Method:** Launches a scheduler specified by its `scx_name` (e.g., "scx_rusty") and a scheduler mode (profile) represented as an unsigned integer.
* **`StartSchedulerWithArgs` Method:** Starts a scheduler with its `scx_name` and allows passing arbitrary CLI arguments directly to the scheduler.
* **`StopScheduler` Method:** Terminates the currently running scheduler.
* **`SwitchScheduler` Method:** Stops the current scheduler and starts the specified scheduler with the given mode.
* **`SwitchSchedulerWithArgs` Method:** Stops the current scheduler and starts the specified scheduler with the provided arguments.
* **`CurrentScheduler` Property:** Returns the `scx_name` of the active scheduler or "unknown" if none is running.
* **`SchedulerMode` Property:** Provides information about the currently active scheduler's mode (profile).
* **`SupportedSchedulers` Property:** Lists the schedulers currently supported by `scx_loader`.
## Usage
`scx_loader` interacts with schedulers through its DBUS interface. You can use tools like `dbus-send` or `gdbus` to communicate with it.
**Examples using `dbus-send`:**
* **Start a Scheduler:**
```bash
dbus-send --system --print-reply --dest=org.scx.Loader /org/scx/Loader org.scx.Loader.StartScheduler string:scx_rusty uint32:0
```
(This starts `scx_rusty` with scheduler mode 0)
* **Start a Scheduler with Arguments:**
```bash
dbus-send --system --print-reply --dest=org.scx.Loader /org/scx/Loader org.scx.Loader.StartSchedulerWithArgs string:scx_bpfland array:string:"-p","-s","5000"
```
(This starts `scx_bpfland` with arguments `-p -s 5000`)
* **Stop the Current Scheduler:**
```bash
dbus-send --system --print-reply --dest=org.scx.Loader /org/scx/Loader org.scx.Loader.StopScheduler
```
* **Switch Scheduler:**
```bash
dbus-send --system --print-reply --dest=org.scx.Loader /org/scx/Loader org.scx.Loader.SwitchScheduler string:scx_lavd uint32:2
```
(This switches to `scx_lavd` with scheduler mode 2)
* **Switch Scheduler with Arguments:**
```bash
dbus-send --system --print-reply --dest=org.scx.Loader /org/scx/Loader org.scx.Loader.SwitchSchedulerWithArgs string:scx_bpfland array:string:"-p","-s","5000"
```
(This switches to `scx_bpfland` with arguments `-p -s 5000`)
* **Get the Currently Active Scheduler:**
```bash
dbus-send --system --print-reply --dest=org.scx.Loader /org/scx/Loader org.freedesktop.DBus.Properties.Get string:org.scx.Loader string:CurrentScheduler
```
* **Get the Supported Schedulers:**
```bash
dbus-send --system --print-reply --dest=org.scx.Loader /org/scx/Loader org.freedesktop.DBus.Properties.Get string:org.scx.Loader string:SupportedSchedulers
```
**Note:** Replace the example scheduler names and arguments with the actual ones you want to use.
## DBUS and Systemd Service
`scx_loader` provides the `org.scx.Loader` DBUS service and is automatically started by `dbus-daemon` when an application calls into this service. Users and administrators do not need to manually start the `scx_loader` daemon.
`scx_loader` is managed by the `scx_loader.service` systemd unit. This service is distinct from the `scx.service` unit, which is used to manage schedulers directly (without DBUS).
## Debugging
In case of issues with `scx_loader`, you can debug the service using the following steps:
1. **Check the service status:**
```bash
systemctl status scx_loader.service
```
2. **View the service logs:**
```bash
journalctl -u scx_loader.service
```
3. **Enable debug logging:** You can temporarily enable debug logging by modifying the systemd service file:
- Edit the service file:
```bash
sudo systemctl edit scx_loader.service
```
- Add the following lines under the `[Service]` section:
```
Environment=RUST_LOG=trace
```
- Restart the service:
```bash
sudo systemctl restart scx_loader.service
```
- Check the logs again for detailed debugging information.
## D-Bus Introspection XML
`scx_loader` provides a D-Bus Introspection XML file that describes its interface. This file can be used by language bindings and tools to interact with the service.
**Using the Introspection XML:**
The introspection XML can be accessed in two ways:
1. **Through the D-Bus introspection interface:**
```bash
dbus-send --system --print-reply --dest=org.scx.Loader /org/scx/Loader org.freedesktop.DBus.Introspectable.Introspect
```
This will output the XML describing the `scx_loader` interface.
2. **From the project repository:**
The XML file is also available in the provided file `org.scx.Loader.xml`.
You can then use this XML with tools like `gdbus-codegen` or other language-specific D-Bus bindings to generate code that interacts with `scx_loader`.
For example, with `gdbus-codegen`, you can generate C code for the interface:
```bash
gdbus-codegen --generate-c-code scx-loader-bindings org.scx.Loader.xml
```
This will produce header and source files that you can use to interact with `scx_loader` from your C code.
## Development Status
`scx_loader` is under active development. Future improvements may include:
* More robust error handling.
* Configuration file.
scx-1.0.12/rust/scx_loader/configuration.md 0000664 0000000 0000000 00000007540 15007705772 0020721 0 ustar 00root root 0000000 0000000 # scx_loader Configuration File
The `scx_loader` can be configured using a TOML file. This file allows you to customize the default scheduler mode, specify custom flags for each supported scheduler and mode, and set a default scheduler to start on boot.
## Configuration File Location
`scx_loader` looks for the configuration file in the following paths (in order):
1. `/etc/scx_loader/config.toml`
2. `/etc/scx_loader.toml`
If no configuration file is found at any of these paths, `scx_loader` will use the built-in default configuration.
## Configuration Structure
The configuration file has the following structure:
```toml
default_sched = "scx_bpfland"
default_mode = "Auto"
[scheds.scx_bpfland]
auto_mode = []
gaming_mode = ["-m", "performance"]
lowlatency_mode = ["-s", "5000", "-S", "500", "-l", "5000", "-m", "performance"]
powersave_mode = ["-m", "powersave"]
[scheds.scx_rusty]
auto_mode = []
gaming_mode = []
lowlatency_mode = []
powersave_mode = []
[scheds.scx_lavd]
auto_mode = []
gaming_mode = ["--performance"]
lowlatency_mode = ["--performance"]
powersave_mode = ["--powersave"]
[scheds.scx_flash]
auto_mode = []
gaming_mode = []
lowlatency_mode = []
powersave_mode = []
[scheds.scx_p2dq]
auto_mode = []
gaming_mode = []
lowlatency_mode = ["-y"]
powersave_mode = []
[scheds.scx_tickless]
auto_mode = []
gaming_mode = ["-f 5000 -s 5000"]
lowlatency_mode = ["-f 5000 -s 1000"]
powersave_mode = ["-f 50 -p"]
```
**`default_sched`:**
* This field specifies the scheduler that will be started automatically when `scx_loader` starts (e.g., on boot).
* It should be set to the name of a supported scheduler (e.g., `"scx_bpfland"`, `"scx_rusty"`, `"scx_lavd"`, `"scx_flash", `"scx_p2dq"``).
* If this field is not present or is set to an empty string, no scheduler will be started automatically.
**`default_mode`:**
* This field specifies the default scheduler mode that will be used when starting a scheduler without explicitly specifying a mode.
* Possible values are: `"Auto"`, `"Gaming"`, `"LowLatency"`, `"PowerSave"`, `"Server"`.
* If this field is not present, it defaults to `"Auto"`.
**`[scheds.scx_name]`:**
* This section defines the custom flags for a specific scheduler. Replace `scx_name` with the actual name of the scheduler (e.g., `scx_bpfland`, `scx_rusty`, `scx_lavd`, `scx_flash`, `scx_p2dq`).
**`auto_mode`, `gaming_mode`, `lowlatency_mode`, `powersave_mode`, `server_mode`:**
* These fields specify the flags to be used for each scheduler mode.
* Each field is an array of strings, where each string represents a flag.
* If a field is not present or is an empty array, the default flags for that mode will be used.
## Example Configuration
The example configuration above shows how to set custom flags for different schedulers and modes, and how to configure `scx_bpfland` to start automatically on boot.
* For `scx_bpfland`:
* Gaming mode: `-m performance`
* Low Latency mode: `-s 5000 -S 500 -l 5000`
* Power Save mode: `-m powersave`
* For `scx_rusty`:
* No custom flags are defined, so the default flags for each mode will be used.
* For `scx_lavd`:
* Gaming mode: `--performance`
* Low Latency mode: `--performance`
* Power Save mode: `--powersave`
* For `scx_flash`:
* No custom flags are defined, so the default flags for each mode will be used.
* For `scx_p2dq`:
* Low Latency mode: `-y`
* Server mode: `--keep-running`
## Fallback Behavior
If a specific flag is not defined in the configuration file, `scx_loader` will fall back to the default flags defined in the code.
## Missing Required Fields
If the `default_mode` field is missing, it will default to `"Auto"`. If a `[scheds.scx_name]` section is missing, or if specific mode flags are missing within that section, the default flags for the corresponding scheduler and mode will be used. If `default_sched` is missing or empty, no scheduler will be started automatically.
scx-1.0.12/rust/scx_loader/meson.build 0000664 0000000 0000000 00000000615 15007705772 0017666 0 ustar 00root root 0000000 0000000 sched = custom_target('scx_loader',
output: '@PLAINNAME@.__PHONY__',
input: 'Cargo.toml',
command: [cargo, 'build', '--manifest-path=@INPUT@', '--target-dir=@OUTDIR@',
cargo_build_args],
env: cargo_env,
depends: sched_deps,
build_by_default: false,
build_always_stale: true)
scx-1.0.12/rust/scx_loader/org.scx.Loader.conf 0000664 0000000 0000000 00000001034 15007705772 0021157 0 ustar 00root root 0000000 0000000
scx-1.0.12/rust/scx_loader/org.scx.Loader.xml 0000664 0000000 0000000 00000007316 15007705772 0021043 0 ustar 00root root 0000000 0000000
scx-1.0.12/rust/scx_loader/src/ 0000775 0000000 0000000 00000000000 15007705772 0016311 5 ustar 00root root 0000000 0000000 scx-1.0.12/rust/scx_loader/src/config.rs 0000664 0000000 0000000 00000024003 15007705772 0020123 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: GPL-2.0
//
// Copyright (c) 2024 Vladislav Nepogodin
// This software may be used and distributed according to the terms of the
// GNU General Public License version 2.
use std::collections::HashMap;
use std::fs;
use std::path::Path;
use anyhow::Result;
use serde::Deserialize;
use serde::Serialize;
use crate::SchedMode;
use crate::SupportedSched;
#[derive(Debug, PartialEq, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct Config {
pub default_sched: Option,
pub default_mode: Option,
pub scheds: HashMap,
}
#[derive(Debug, PartialEq, Default, Serialize, Deserialize)]
pub struct Sched {
pub auto_mode: Option>,
pub gaming_mode: Option>,
pub lowlatency_mode: Option>,
pub powersave_mode: Option>,
pub server_mode: Option>,
}
/// Initialize config from first found config path, overwise fallback to default config
pub fn init_config() -> Result {
if let Ok(config_path) = get_config_path() {
parse_config_file(&config_path)
} else {
Ok(get_default_config())
}
}
pub fn parse_config_file(filepath: &str) -> Result {
let file_content = fs::read_to_string(filepath)?;
parse_config_content(&file_content)
}
pub fn get_config_path() -> Result {
// Search in system directories
let check_paths = [
"/etc/scx_loader/config.toml".to_owned(),
"/etc/scx_loader.toml".to_owned(),
];
for check_path in check_paths {
if !Path::new(&check_path).exists() {
continue;
}
// we found config path
return Ok(check_path);
}
anyhow::bail!("Failed to find config!");
}
fn parse_config_content(file_content: &str) -> Result {
if file_content.is_empty() {
anyhow::bail!("The config file is empty!")
}
let config: Config = toml::from_str(file_content)?;
Ok(config)
}
pub fn get_default_config() -> Config {
Config {
default_sched: None,
default_mode: Some(SchedMode::Auto),
scheds: HashMap::from([
(
"scx_bpfland".to_string(),
get_default_sched_for_config(&SupportedSched::Bpfland),
),
(
"scx_rusty".to_string(),
get_default_sched_for_config(&SupportedSched::Rusty),
),
(
"scx_lavd".to_string(),
get_default_sched_for_config(&SupportedSched::Lavd),
),
(
"scx_flash".to_string(),
get_default_sched_for_config(&SupportedSched::Flash),
),
(
"scx_p2dq".to_string(),
get_default_sched_for_config(&SupportedSched::P2DQ),
),
(
"scx_tickless".to_string(),
get_default_sched_for_config(&SupportedSched::Tickless),
),
]),
}
}
/// Get the scx flags for the given sched mode
pub fn get_scx_flags_for_mode(
config: &Config,
scx_sched: &SupportedSched,
sched_mode: SchedMode,
) -> Vec {
let scx_name: &str = scx_sched.clone().into();
if let Some(sched_config) = config.scheds.get(scx_name) {
let scx_flags = extract_scx_flags_from_config(sched_config, &sched_mode);
// try to exact flags from config, otherwise fallback to hardcoded default
scx_flags.unwrap_or({
get_default_scx_flags_for_mode(scx_sched, sched_mode)
.into_iter()
.map(String::from)
.collect()
})
} else {
get_default_scx_flags_for_mode(scx_sched, sched_mode)
.into_iter()
.map(String::from)
.collect()
}
}
/// Extract the scx flags from config
fn extract_scx_flags_from_config(
sched_config: &Sched,
sched_mode: &SchedMode,
) -> Option> {
match sched_mode {
SchedMode::Gaming => sched_config.gaming_mode.clone(),
SchedMode::LowLatency => sched_config.lowlatency_mode.clone(),
SchedMode::PowerSave => sched_config.powersave_mode.clone(),
SchedMode::Server => sched_config.server_mode.clone(),
SchedMode::Auto => sched_config.auto_mode.clone(),
}
}
/// Get Sched object for configuration object
fn get_default_sched_for_config(scx_sched: &SupportedSched) -> Sched {
Sched {
auto_mode: Some(
get_default_scx_flags_for_mode(scx_sched, SchedMode::Auto)
.into_iter()
.map(String::from)
.collect(),
),
gaming_mode: Some(
get_default_scx_flags_for_mode(scx_sched, SchedMode::Gaming)
.into_iter()
.map(String::from)
.collect(),
),
lowlatency_mode: Some(
get_default_scx_flags_for_mode(scx_sched, SchedMode::LowLatency)
.into_iter()
.map(String::from)
.collect(),
),
powersave_mode: Some(
get_default_scx_flags_for_mode(scx_sched, SchedMode::PowerSave)
.into_iter()
.map(String::from)
.collect(),
),
server_mode: Some(
get_default_scx_flags_for_mode(scx_sched, SchedMode::Server)
.into_iter()
.map(String::from)
.collect(),
),
}
}
/// Get the default scx flags for the given sched mode
fn get_default_scx_flags_for_mode(scx_sched: &SupportedSched, sched_mode: SchedMode) -> Vec<&str> {
match scx_sched {
SupportedSched::Bpfland => match sched_mode {
SchedMode::Gaming => vec!["-m", "performance"],
SchedMode::LowLatency => {
vec!["-s", "5000", "-S", "500", "-l", "5000", "-m", "performance"]
}
SchedMode::PowerSave => vec!["-m", "powersave"],
SchedMode::Server => vec!["-p"],
SchedMode::Auto => vec![],
},
SupportedSched::Lavd => match sched_mode {
SchedMode::Gaming | SchedMode::LowLatency => vec!["--performance"],
SchedMode::PowerSave => vec!["--powersave"],
// NOTE: potentially adding --auto in future
SchedMode::Server | SchedMode::Auto => vec![],
},
// scx_rusty doesn't support any of these modes
SupportedSched::Rusty => vec![],
// scx_flash doesn't support any of these modes
SupportedSched::Flash => vec![],
SupportedSched::P2DQ => match sched_mode {
SchedMode::Gaming => vec![],
SchedMode::LowLatency => vec!["-y"],
SchedMode::PowerSave => vec![],
SchedMode::Server => vec!["--keep-running"],
SchedMode::Auto => vec![],
},
SupportedSched::Tickless => match sched_mode {
SchedMode::Gaming => vec!["-f", "5000", "-s", "5000"],
SchedMode::LowLatency => vec!["-f", "5000", "-s", "1000"],
SchedMode::PowerSave => vec!["-f", "50", "-p"],
SchedMode::Server => vec!["-f", "100"],
SchedMode::Auto => vec![],
},
}
}
#[cfg(test)]
mod tests {
use crate::config::*;
#[test]
fn test_default_config() {
let config_str = r#"
default_mode = "Auto"
[scheds.scx_bpfland]
auto_mode = []
gaming_mode = ["-m", "performance"]
lowlatency_mode = ["-s", "5000", "-S", "500", "-l", "5000", "-m", "performance"]
powersave_mode = ["-m", "powersave"]
server_mode = ["-p"]
[scheds.scx_rusty]
auto_mode = []
gaming_mode = []
lowlatency_mode = []
powersave_mode = []
server_mode = []
[scheds.scx_lavd]
auto_mode = []
gaming_mode = ["--performance"]
lowlatency_mode = ["--performance"]
powersave_mode = ["--powersave"]
server_mode = []
[scheds.scx_flash]
auto_mode = []
gaming_mode = []
lowlatency_mode = []
powersave_mode = []
server_mode = []
[scheds.scx_p2dq]
auto_mode = []
gaming_mode = []
lowlatency_mode = ["-y"]
powersave_mode = []
server_mode = ["--keep-running"]
[scheds.scx_tickless]
auto_mode = []
gaming_mode = ["-f", "5000", "-s", "5000"]
lowlatency_mode = ["-f", "5000", "-s", "1000"]
powersave_mode = ["-f", "50", "-p"]
server_mode = ["-f", "100"]
"#;
let parsed_config = parse_config_content(config_str).expect("Failed to parse config");
let expected_config = get_default_config();
assert_eq!(parsed_config, expected_config);
}
#[test]
fn test_simple_fallback_config_flags() {
let config_str = r#"
default_mode = "Auto"
"#;
let parsed_config = parse_config_content(config_str).expect("Failed to parse config");
let bpfland_flags =
get_scx_flags_for_mode(&parsed_config, &SupportedSched::Bpfland, SchedMode::Gaming);
let expected_flags =
get_default_scx_flags_for_mode(&SupportedSched::Bpfland, SchedMode::Gaming);
assert_eq!(
bpfland_flags
.iter()
.map(|x| x.as_str())
.collect::>(),
expected_flags
);
}
#[test]
fn test_sched_fallback_config_flags() {
let config_str = r#"
default_mode = "Auto"
[scheds.scx_lavd]
auto_mode = ["--help"]
"#;
let parsed_config = parse_config_content(config_str).expect("Failed to parse config");
let lavd_flags =
get_scx_flags_for_mode(&parsed_config, &SupportedSched::Lavd, SchedMode::Gaming);
let expected_flags =
get_default_scx_flags_for_mode(&SupportedSched::Lavd, SchedMode::Gaming);
assert_eq!(
lavd_flags.iter().map(|x| x.as_str()).collect::>(),
expected_flags
);
let lavd_flags =
get_scx_flags_for_mode(&parsed_config, &SupportedSched::Lavd, SchedMode::Auto);
assert_eq!(
lavd_flags.iter().map(|x| x.as_str()).collect::>(),
vec!["--help"]
);
}
#[test]
fn test_empty_config() {
let config_str = "";
let result = parse_config_content(config_str);
assert!(result.is_err());
}
}
scx-1.0.12/rust/scx_loader/src/dbus.rs 0000664 0000000 0000000 00000004462 15007705772 0017622 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: GPL-2.0
//
// Copyright (c) 2024 Vladislav Nepogodin
// This software may be used and distributed according to the terms of the
// GNU General Public License version 2.
use crate::SchedMode;
use crate::SupportedSched;
#[zbus::proxy(
interface = "org.scx.Loader",
default_service = "org.scx.Loader",
default_path = "/org/scx/Loader"
)]
pub trait LoaderClient {
/// Starts the specified scheduler with the given mode.
fn start_scheduler(&self, scx_name: SupportedSched, sched_mode: SchedMode) -> zbus::Result<()>;
/// Starts the specified scheduler with the provided arguments.
fn start_scheduler_with_args(
&self,
scx_name: SupportedSched,
scx_args: &[String],
) -> zbus::Result<()>;
/// Stops the currently running scheduler.
fn stop_scheduler(&self) -> zbus::Result<()>;
/// Method for switching to the specified scheduler with the given mode.
/// This method will stop the currently running scheduler (if any) and
/// then start the new scheduler.
fn switch_scheduler(&self, scx_name: SupportedSched, sched_mode: SchedMode)
-> zbus::Result<()>;
/// Switches to the specified scheduler with the provided arguments. This
/// method will stop the currently running scheduler (if any) and then
/// start the new scheduler with the given arguments.
fn switch_scheduler_with_args(
&self,
scx_name: SupportedSched,
scx_args: &[String],
) -> zbus::Result<()>;
/// The name of the currently running scheduler. If no scheduler is active,
/// this property will be set to "unknown".
#[zbus(property)]
fn current_scheduler(&self) -> zbus::Result;
/// The currently active scheduler mode. Scheduler modes allow you to
/// apply pre-defined configurations to a scheduler that are
/// optimized for different use cases. If no scheduler is active,
/// this property will be set to 0 (Auto).
#[zbus(property)]
fn scheduler_mode(&self) -> zbus::Result;
/// A list of the schedulers currently supported by the Scheduler Loader.
/// The names of the supported schedulers will be listed as strings in
/// this array.
#[zbus(property)]
fn supported_schedulers(&self) -> zbus::Result>;
}
scx-1.0.12/rust/scx_loader/src/lib.rs 0000664 0000000 0000000 00000006664 15007705772 0017441 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: GPL-2.0
//
// Copyright (c) 2024 Vladislav Nepogodin
// This software may be used and distributed according to the terms of the
// GNU General Public License version 2.
pub mod config;
pub mod dbus;
use std::str::FromStr;
use serde::Deserialize;
use serde::Serialize;
use zvariant::OwnedValue;
use zvariant::Type;
use zvariant::Value;
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Type)]
#[zvariant(signature = "s")]
#[serde(rename_all = "lowercase")]
pub enum SupportedSched {
#[serde(rename = "scx_bpfland")]
Bpfland,
#[serde(rename = "scx_rusty")]
Rusty,
#[serde(rename = "scx_lavd")]
Lavd,
#[serde(rename = "scx_flash")]
Flash,
#[serde(rename = "scx_p2dq")]
P2DQ,
#[serde(rename = "scx_tickless")]
Tickless,
}
impl FromStr for SupportedSched {
type Err = anyhow::Error;
fn from_str(scx_name: &str) -> anyhow::Result {
match scx_name {
"scx_bpfland" => Ok(SupportedSched::Bpfland),
"scx_flash" => Ok(SupportedSched::Flash),
"scx_lavd" => Ok(SupportedSched::Lavd),
"scx_p2dq" => Ok(SupportedSched::P2DQ),
"scx_tickless" => Ok(SupportedSched::Tickless),
"scx_rusty" => Ok(SupportedSched::Rusty),
_ => Err(anyhow::anyhow!("{scx_name} is not supported")),
}
}
}
impl TryFrom<&str> for SupportedSched {
type Error = ::Err;
fn try_from(s: &str) -> Result {
::from_str(s)
}
}
impl From for &str {
fn from(scx_name: SupportedSched) -> Self {
match scx_name {
SupportedSched::Bpfland => "scx_bpfland",
SupportedSched::Flash => "scx_flash",
SupportedSched::Lavd => "scx_lavd",
SupportedSched::P2DQ => "scx_p2dq",
SupportedSched::Tickless => "scx_tickless",
SupportedSched::Rusty => "scx_rusty",
}
}
}
#[derive(Debug, Clone, Deserialize, Serialize, Type, Value, OwnedValue, PartialEq)]
pub enum SchedMode {
/// Default values for the scheduler
Auto = 0,
/// Applies flags for better gaming experience
Gaming = 1,
/// Applies flags for lower power usage
PowerSave = 2,
/// Starts scheduler in low latency mode
LowLatency = 3,
/// Starts scheduler in server-oriented mode
Server = 4,
}
impl FromStr for SchedMode {
type Err = anyhow::Error;
fn from_str(mode_name: &str) -> anyhow::Result {
match mode_name {
"auto" => Ok(SchedMode::Auto),
"gaming" => Ok(SchedMode::Gaming),
"powersave" => Ok(SchedMode::PowerSave),
"lowlatency" => Ok(SchedMode::LowLatency),
"server" => Ok(SchedMode::Server),
_ => Err(anyhow::anyhow!("{mode_name} is not supported")),
}
}
}
impl TryFrom<&str> for SchedMode {
type Error = ::Err;
fn try_from(s: &str) -> Result {
::from_str(s)
}
}
impl From for &str {
fn from(mode_name: SchedMode) -> Self {
match mode_name {
SchedMode::Auto => "auto",
SchedMode::Gaming => "gaming",
SchedMode::PowerSave => "powersave",
SchedMode::LowLatency => "lowlatency",
SchedMode::Server => "server",
}
}
}
scx-1.0.12/rust/scx_loader/src/logger.rs 0000664 0000000 0000000 00000003160 15007705772 0020136 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: GPL-2.0
//
// Copyright (c) 2024 Vladislav Nepogodin
// This software may be used and distributed according to the terms of the
// GNU General Public License version 2.
use std::env;
use colored::Colorize;
use log::Level;
use log::Metadata;
use log::Record;
struct SimpleLogger;
static LOGGER: SimpleLogger = SimpleLogger;
impl log::Log for SimpleLogger {
fn enabled(&self, _: &Metadata) -> bool {
true
}
fn log(&self, record: &Record) {
if self.enabled(record.metadata()) {
let level_str = match record.level() {
Level::Error => "[ERROR]".red(),
Level::Warn => "[WARN]".yellow(),
Level::Info => "[INFO]".red(),
Level::Debug => "[DEBUG]".white(),
Level::Trace => "[TRACE]".black(),
};
println!("{level_str}: {}", record.args());
}
}
fn flush(&self) {
// use std::io::Write;
// io::stdout().flush().unwrap();
}
}
pub fn init_logger() -> Result<(), log::SetLoggerError> {
// set log level
let max_log_level = if let Ok(env_log) = env::var("RUST_LOG") {
let env_log = env_log.to_lowercase();
match env_log.as_str() {
"trace" => log::LevelFilter::Trace,
"debug" => log::LevelFilter::Debug,
"warn" => log::LevelFilter::Warn,
"error" => log::LevelFilter::Error,
_ => log::LevelFilter::Info,
}
} else {
log::LevelFilter::Info
};
log::set_logger(&LOGGER).map(|()| log::set_max_level(max_log_level))
}
scx-1.0.12/rust/scx_loader/src/main.rs 0000664 0000000 0000000 00000042761 15007705772 0017615 0 ustar 00root root 0000000 0000000 // SPDX-License-Identifier: GPL-2.0
//
// Copyright (c) 2024 Vladislav Nepogodin
// This software may be used and distributed according to the terms of the
// GNU General Public License version 2.
mod logger;
use scx_loader::dbus::LoaderClientProxy;
use scx_loader::*;
use std::process::ExitStatus;
use std::process::Stdio;
use std::sync::Arc;
use anyhow::Context;
use anyhow::Result;
use clap::Parser;
use sysinfo::System;
use tokio::process::Child;
use tokio::process::Command;
use tokio::sync::mpsc::UnboundedReceiver;
use tokio::sync::mpsc::UnboundedSender;
use tokio::time::Duration;
use tokio::time::Instant;
use zbus::interface;
use zbus::Connection;
#[derive(Debug, PartialEq)]
enum ScxMessage {
/// Quit the scx_loader
Quit,
/// Stop the scheduler, if any
StopSched,
/// Start the scheduler with the given mode
StartSched((SupportedSched, SchedMode)),
/// Start the scheduler with the given scx arguments
StartSchedArgs((SupportedSched, Vec)),
/// Switch to another scheduler with the given mode
SwitchSched((SupportedSched, SchedMode)),
/// Switch to another scheduler with the given scx arguments
SwitchSchedArgs((SupportedSched, Vec)),
}
#[derive(Debug, PartialEq)]
enum RunnerMessage {
/// Switch to another scheduler with the given scx arguments
Switch((SupportedSched, Vec)),
/// Start the scheduler with the given scx arguments
Start((SupportedSched, Vec)),
/// Stop the scheduler, if any
Stop,
}
struct ScxLoader {
current_scx: Option,
current_mode: SchedMode,
channel: UnboundedSender,
}
#[derive(Parser, Debug)]
#[clap(author, version, about, long_about = None)]
struct Args {
#[clap(long, short, action)]
auto: bool,
}
#[interface(name = "org.scx.Loader")]
impl ScxLoader {
/// Get currently running scheduler, in case non is running return "unknown"
#[zbus(property)]
async fn current_scheduler(&self) -> String {
if let Some(current_scx) = &self.current_scx {
let current_scx: &str = current_scx.clone().into();
log::info!("called {current_scx:?}");
return current_scx.to_owned();
}
"unknown".to_owned()
}
/// Get scheduler mode
#[zbus(property)]
async fn scheduler_mode(&self) -> SchedMode {
self.current_mode.clone()
}
/// Get list of supported schedulers
#[zbus(property)]
async fn supported_schedulers(&self) -> Vec<&str> {
vec![
"scx_bpfland",
"scx_flash",
"scx_lavd",
"scx_p2dq",
"scx_tickless",
"scx_rusty",
]
}
async fn start_scheduler(
&mut self,
scx_name: SupportedSched,
sched_mode: SchedMode,
) -> zbus::fdo::Result<()> {
log::info!("starting {scx_name:?} with mode {sched_mode:?}..");
let _ = self.channel.send(ScxMessage::StartSched((
scx_name.clone(),
sched_mode.clone(),
)));
self.current_scx = Some(scx_name);
self.current_mode = sched_mode;
Ok(())
}
async fn start_scheduler_with_args(
&mut self,
scx_name: SupportedSched,
scx_args: Vec,
) -> zbus::fdo::Result<()> {
log::info!("starting {scx_name:?} with args {scx_args:?}..");
let _ = self
.channel
.send(ScxMessage::StartSchedArgs((scx_name.clone(), scx_args)));
self.current_scx = Some(scx_name);
// reset mode to auto
self.current_mode = SchedMode::Auto;
Ok(())
}
async fn switch_scheduler(
&mut self,
scx_name: SupportedSched,
sched_mode: SchedMode,
) -> zbus::fdo::Result<()> {
log::info!("switching {scx_name:?} with mode {sched_mode:?}..");
let _ = self.channel.send(ScxMessage::SwitchSched((
scx_name.clone(),
sched_mode.clone(),
)));
self.current_scx = Some(scx_name);
self.current_mode = sched_mode;
Ok(())
}
async fn switch_scheduler_with_args(
&mut self,
scx_name: SupportedSched,
scx_args: Vec,
) -> zbus::fdo::Result<()> {
log::info!("switching {scx_name:?} with args {scx_args:?}..");
let _ = self
.channel
.send(ScxMessage::SwitchSchedArgs((scx_name.clone(), scx_args)));
self.current_scx = Some(scx_name);
// reset mode to auto
self.current_mode = SchedMode::Auto;
Ok(())
}
async fn stop_scheduler(&mut self) -> zbus::fdo::Result<()> {
if let Some(current_scx) = &self.current_scx {
let scx_name: &str = current_scx.clone().into();
log::info!("stopping {scx_name:?}..");
let _ = self.channel.send(ScxMessage::StopSched);
self.current_scx = None;
}
Ok(())
}
}
// Monitors CPU utilization and enables scx_lavd when utilization of any CPUs is > 90%
async fn monitor_cpu_util() -> Result<()> {
let mut system = System::new_all();
let mut running_sched: Option = None;
let mut cpu_above_threshold_since: Option = None;
let mut cpu_below_threshold_since: Option = None;
let high_utilization_threshold = 90.0;
let low_utilization_threshold_duration = Duration::from_secs(30);
let high_utilization_trigger_duration = Duration::from_secs(5);
loop {
system.refresh_cpu_all();
let any_cpu_above_threshold = system
.cpus()
.iter()
.any(|cpu| cpu.cpu_usage() > high_utilization_threshold);
if any_cpu_above_threshold {
if cpu_above_threshold_since.is_none() {
cpu_above_threshold_since = Some(Instant::now());
}
if cpu_above_threshold_since.unwrap().elapsed() > high_utilization_trigger_duration {
if running_sched.is_none() {
log::info!("CPU Utilization exceeded 90% for 5 seconds, starting scx_lavd");
let scx_name: &str = SupportedSched::Lavd.into();
running_sched = Some(
Command::new(scx_name)
.spawn()
.expect("Failed to start scx_lavd"),
);
}
cpu_below_threshold_since = None;
}
} else {
cpu_above_threshold_since = None;
if cpu_below_threshold_since.is_none() {
cpu_below_threshold_since = Some(Instant::now());
}
if cpu_below_threshold_since.unwrap().elapsed() > low_utilization_threshold_duration {
if let Some(mut running_sched_loc) = running_sched.take() {
log::info!(
"CPU utilization dropped below 90% for more than 30 seconds, exiting latency-aware scheduler"
);
running_sched_loc
.kill()
.await
.expect("Failed to kill scx_lavd");
let lavd_exit_status = running_sched_loc
.wait()
.await
.expect("Failed to wait on scx_lavd");
log::info!("scx_lavd exited with status: {}", lavd_exit_status);
}
}
}
tokio::time::sleep(Duration::from_secs(1)).await;
}
}
#[tokio::main]
async fn main() -> Result<()> {
// initialize the logger
logger::init_logger().expect("Failed to initialize logger");
let args = Args::parse();
// initialize the config
let config = config::init_config().context("Failed to initialize config")?;
// If --auto is passed, start scx_loader as a standard background process
// that swaps schedulers out automatically
// based on CPU utilization without registering a dbus interface.
if args.auto {
log::info!("Starting scx_loader monitor as standard process without dbus interface");
monitor_cpu_util().await?;
return Ok(());
}
log::info!("Starting as dbus interface");
// setup channel
let (channel, rx) = tokio::sync::mpsc::unbounded_channel::();
let channel_clone = channel.clone();
ctrlc::set_handler(move || {
log::info!("shutting down..");
let _ = channel_clone.send(ScxMessage::Quit);
})
.context("Error setting Ctrl-C handler")?;
// register dbus interface
let connection = Connection::system().await?;
connection
.object_server()
.at(
"/org/scx/Loader",
ScxLoader {
current_scx: None,
current_mode: SchedMode::Auto,
channel: channel.clone(),
},
)
.await?;
connection.request_name("org.scx.Loader").await?;
// if user set default scheduler, then start it
if let Some(default_sched) = &config.default_sched {
log::info!("Starting default scheduler: {default_sched:?}");
let default_mode = config.default_mode.clone().unwrap_or(SchedMode::Auto);
let loader_client = LoaderClientProxy::new(&connection).await?;
loader_client
.switch_scheduler(default_sched.clone(), default_mode)
.await?;
}
// run worker/receiver loop
worker_loop(config, rx).await?;
Ok(())
}
async fn worker_loop(
config: config::Config,
mut receiver: UnboundedReceiver,
) -> Result<()> {
// setup channel for scheduler runner
let (runner_tx, runner_rx) = tokio::sync::mpsc::channel::(1);
let run_sched_future = tokio::spawn(async move { handle_child_process(runner_rx).await });
// prepare future for tokio
tokio::pin!(run_sched_future);
loop {
// handle each future here
let msg = tokio::select! {
msg = receiver.recv() => {
match msg {
None => return Ok(()),
Some(m) => m,
}
}
res = &mut run_sched_future => {
log::info!("Sched future finished");
let _ = res?;
continue;
}
};
log::debug!("Got msg : {msg:?}");
match msg {
ScxMessage::Quit => return Ok(()),
ScxMessage::StopSched => {
log::info!("Got event to stop scheduler!");
// send stop message to the runner
runner_tx.send(RunnerMessage::Stop).await?;
}
ScxMessage::StartSched((scx_sched, sched_mode)) => {
log::info!("Got event to start scheduler!");
// get scheduler args for the mode
let args = config::get_scx_flags_for_mode(&config, &scx_sched, sched_mode);
// send message with scheduler and asociated args to the runner
runner_tx
.send(RunnerMessage::Start((scx_sched, args)))
.await?;
}
ScxMessage::StartSchedArgs((scx_sched, sched_args)) => {
log::info!("Got event to start scheduler with args!");
// send message with scheduler and asociated args to the runner
runner_tx
.send(RunnerMessage::Start((scx_sched, sched_args)))
.await?;
}
ScxMessage::SwitchSched((scx_sched, sched_mode)) => {
log::info!("Got event to switch scheduler!");
// get scheduler args for the mode
let args = config::get_scx_flags_for_mode(&config, &scx_sched, sched_mode);
// send message with scheduler and asociated args to the runner
runner_tx
.send(RunnerMessage::Switch((scx_sched, args)))
.await?;
}
ScxMessage::SwitchSchedArgs((scx_sched, sched_args)) => {
log::info!("Got event to switch scheduler with args!");
// send message with scheduler and asociated args to the runner
runner_tx
.send(RunnerMessage::Switch((scx_sched, sched_args)))
.await?;
}
}
}
}
async fn handle_child_process(mut rx: tokio::sync::mpsc::Receiver) -> Result<()> {
let mut task: Option>>> = None;
let mut cancel_token = Arc::new(tokio_util::sync::CancellationToken::new());
while let Some(message) = rx.recv().await {
match message {
RunnerMessage::Switch((scx_sched, sched_args)) => {
// stop the sched if its running
stop_scheduler(&mut task, &mut cancel_token).await;
// overwise start scheduler
match start_scheduler(scx_sched, sched_args, cancel_token.clone()).await {
Ok(handle) => {
task = Some(handle);
log::debug!("Scheduler started");
}
Err(err) => {
log::error!("Failed to start scheduler: {err}");
}
}
}
RunnerMessage::Start((scx_sched, sched_args)) => {
// check if sched is running or not
if task.is_some() {
log::error!("Scheduler wasn't finished yet. Stop already running scheduler!");
continue;
}
// overwise start scheduler
match start_scheduler(scx_sched, sched_args, cancel_token.clone()).await {
Ok(handle) => {
task = Some(handle);
log::debug!("Scheduler started");
}
Err(err) => {
log::error!("Failed to start scheduler: {err}");
}
}
}
RunnerMessage::Stop => {
stop_scheduler(&mut task, &mut cancel_token).await;
}
}
}
Ok(())
}
/// Start the scheduler with the given arguments
async fn start_scheduler(
scx_crate: SupportedSched,
args: Vec,
cancel_token: Arc,
) -> Result>>> {
// Ensure the child process exit is handled correctly in the runtime
let handle = tokio::spawn(async move {
let mut retries = 0u32;
let max_retries = 5u32;
let mut last_status: Option = None;
while retries < max_retries {
let child = spawn_scheduler(scx_crate.clone(), args.clone()).await;
let mut failed = false;
if let Ok(mut child) = child {
tokio::select! {
status = child.wait() => {
let status = status.expect("child process encountered an error");
last_status = Some(status);
if !status.success() {
failed = true;
}
log::debug!("Child process exited with status: {status:?}");
}
_ = cancel_token.cancelled() => {
log::debug!("Received cancellation signal");
// Send SIGINT
if let Some(child_id) = child.id() {
nix::sys::signal::kill(
nix::unistd::Pid::from_raw(child_id as i32),
nix::sys::signal::SIGINT,
).context("Failed to send termination signal to the child")?;
}
let status = child.wait().await.expect("child process encountered an error");
last_status = Some(status);
break;
}
};
} else {
log::debug!("Failed to spawn child process");
failed = true;
}
// retrying if failed, otherwise exit
if !failed {
break;
}
retries += 1;
log::error!(
"Failed to start scheduler (attempt {}/{})",
retries,
max_retries,
);
}
Ok(last_status)
});
Ok(handle)
}
/// Starts the scheduler as a child process and returns child object to manage lifecycle by the
/// caller.
async fn spawn_scheduler(scx_crate: SupportedSched, args: Vec) -> Result {
let sched_bin_name: &str = scx_crate.into();
log::info!("starting {sched_bin_name} command");
let mut cmd = Command::new(sched_bin_name);
// set arguments
cmd.args(args);
// by default child IO handles are inherited from parent process
// pipe stdin of child proc to /dev/null
cmd.stdin(Stdio::null());
// spawn process
let child = cmd.spawn().expect("failed to spawn command");
Ok(child)
}
async fn stop_scheduler(
task: &mut Option>>>,
cancel_token: &mut Arc,
) {
if let Some(task) = task.take() {
log::debug!("Stopping already running scheduler..");
cancel_token.cancel();
let status = task.await;
log::debug!("Scheduler was stopped with status: {:?}", status);
// Create a new cancellation token
*cancel_token = Arc::new(tokio_util::sync::CancellationToken::new());
}
}
scx-1.0.12/rust/scx_rustland_core/ 0000775 0000000 0000000 00000000000 15007705772 0017120 5 ustar 00root root 0000000 0000000 scx-1.0.12/rust/scx_rustland_core/Cargo.toml 0000664 0000000 0000000 00000001360 15007705772 0021050 0 ustar 00root root 0000000 0000000 [package]
name = "scx_rustland_core"
version = "2.2.11"
edition = "2021"
authors = ["Andrea Righi "]
license = "GPL-2.0-only"
repository = "https://github.com/sched-ext/scx"
description = "Framework to implement sched_ext schedulers running in user space"
[dependencies]
anyhow = "1.0.65"
plain = "0.2.3"
libbpf-rs = "=0.25.0-beta.1"
libc = "0.2.137"
seccomp = "0.1"
scx_utils = { path = "../scx_utils", version = "1.0.15" }
[build-dependencies]
tar = "0.4"
walkdir = "2.5"
scx_utils = { path = "../scx_utils", version = "1.0.15" }
[lib]
name = "scx_rustland_core"
path = "src/lib.rs"
include = [
"assets/bpf/intf.h",
"assets/bpf/main.bpf.c",
"assets/bpf.rs",
]
[lints.clippy]
not_unsafe_ptr_arg_deref = "allow"
scx-1.0.12/rust/scx_rustland_core/LICENSE 0000777 0000000 0000000 00000000000 15007705772 0021553 2../../LICENSE ustar 00root root 0000000 0000000 scx-1.0.12/rust/scx_rustland_core/README.md 0000664 0000000 0000000 00000012233 15007705772 0020400 0 ustar 00root root 0000000 0000000 # Framework to implement `sched_ext` schedulers running in user-space
`scx_rustland_core` is a Rust framework designed to facilitate the
implementation of user-space schedulers based on the Linux kernel
`sched_ext` feature.
`sched_ext` allows to dynamic load and execute custom schedulers in the
kernel, leveraging BPF to manage scheduling policies.
This crate provides an abstraction layer for `sched_ext`, enabling
developers to write schedulers in Rust without dealing with low-level
kernel or BPF details.
## Features
- **Generic BPF Abstraction**: Interact with BPF components using a
high-level Rust API.
- **Task Scheduling**: Enqueue and dispatch tasks using provided methods.
- **CPU Selection**: Select idle CPUs for task execution with a preference
for reusing previous CPUs.
- **Time slice**: Assign a specific time slice on a per-task basis.
- **Performance Reporting**: Access internal scheduling statistics.
## API
### `BpfScheduler`
The `BpfScheduler` struct is the core interface for interacting with the BPF
component.
- **Initialization**:
- `BpfScheduler::init` registers and initializes the BPF component.
- **Task Management**:
- `dequeue_task()`: Retrieve tasks that need to be scheduled.
- `dispatch_task(task: &DispatchedTask)`: Dispatch tasks to specific CPUs.
- `select_cpu(pid: i32, prev_cpu: i32, flags: u64)`: Select an idle CPU for a task.
- **Completion Notification**:
- `notify_complete(nr_pending: u64)` reports the number of pending tasks
to the BPF component.
## Getting Started
- **Installation**:
- Add `scx_rustland_core` to your `Cargo.toml` dependencies.
- **Implementation**:
- Create your scheduler by implementing the provided API.
- **Execution**:
- Compile and run your scheduler. Ensure that your kernel supports
`sched_ext` and is configured to load your BPF programs.
### struct `BpfScheduler`
The `BpfScheduler` struct is the core interface for interacting with
`sched_ext` via BPF.
- **Initialization**:
- `BpfScheduler::init()` registers the scheduler and initializes the BPF
component.
- **Task Management**:
- `dequeue_task()`: Consume a task that wants to run, returns a
QueuedTask object
- `select_cpu(pid: i32, prev_cpu: i32, flags: u64)`: Select an idle CPU
for a task
- `dispatch_task(task: &DispatchedTask)`: Dispatch a task
- **Completion Notification**:
- `notify_complete(nr_pending: u64)`: Give control to the BPF component
and report the number of tasks that are still pending (this function
can sleep)
Each task received from `.dequeue_task()` contains the following:
```
struct QueuedTask {
pub pid: i32, // pid that uniquely identifies a task
pub cpu: i32, // CPU previously used by the task
pub flags: u64, // task's enqueue flags
pub exec_runtime: u64, // Total cpu time in nanoseconds
pub sum_exec_runtime: u64, // Total cpu time in nanoseconds
pub weight: u64, // Task priority in the range [1..10000] (default is 100)
pub nvcsw: u64, // Total amount of voluntary context switches
pub slice: u64, // Remaining time slice budget
pub vtime: u64, // Current task vruntime / deadline (set by the scheduler)
}
```
Each task dispatched using `.dispatch_task()` contains the following:
```
struct DispatchedTask {
pub pid: i32, // pid that uniquely identifies a task
pub cpu: i32, // target CPU selected by the scheduler
// (RL_CPU_ANY = dispatch on the first CPU available)
pub flags: u64, // task's enqueue flags
pub slice_ns: u64, // time slice in nanoseconds assigned to the task
// (0 = use default time slice)
pub vtime: u64, // this value can be used to send the task's vruntime or deadline
// directly to the underlying BPF dispatcher
}
```
Other internal statistics that can be used to implement better scheduling policies:
```
let n: u64 = *self.bpf.nr_online_cpus_mut(); // amount of online CPUs
let n: u64 = *self.bpf.nr_running_mut(); // amount of currently running tasks
let n: u64 = *self.bpf.nr_queued_mut(); // amount of tasks queued to be scheduled
let n: u64 = *self.bpf.nr_scheduled_mut(); // amount of tasks managed by the user-space scheduler
let n: u64 = *self.bpf.nr_user_dispatches_mut(); // amount of user-space dispatches
let n: u64 = *self.bpf.nr_kernel_dispatches_mut(); // amount of kernel dispatches
let n: u64 = *self.bpf.nr_cancel_dispatches_mut(); // amount of cancelled dispatches
let n: u64 = *self.bpf.nr_bounce_dispatches_mut(); // amount of bounced dispatches
let n: u64 = *self.bpf.nr_failed_dispatches_mut(); // amount of failed dispatches
let n: u64 = *self.bpf.nr_sched_congested_mut(); // amount of scheduler congestion events
```
## Example
Check out
[scx_rlfifo](https://github.com/sched-ext/scx/tree/main/scheds/rust/scx_rlfifo)
for a basic implementation of a working round-robin scheduler.
## License
This software is licensed under the GNU General Public License version 2. See
the LICENSE file for details.
## Contributing
Contributions are welcome! Please submit issues or pull requests via GitHub.
scx-1.0.12/rust/scx_rustland_core/assets/ 0000775 0000000 0000000 00000000000 15007705772 0020422 5 ustar 00root root 0000000 0000000 scx-1.0.12/rust/scx_rustland_core/assets/bpf.rs 0000664 0000000 0000000 00000050352 15007705772 0021544 0 ustar 00root root 0000000 0000000 // Copyright (c) Andrea Righi
// This software may be used and distributed according to the terms of the
// GNU General Public License version 2.
use std::mem::MaybeUninit;
use crate::bpf_intf;
use crate::bpf_intf::*;
use crate::bpf_skel::*;
use std::ffi::c_int;
use std::ffi::c_ulong;
use std::collections::HashMap;
use std::sync::atomic::AtomicBool;
use std::sync::atomic::Ordering;
use std::sync::Arc;
use std::sync::Once;
use anyhow::Context;
use anyhow::Result;
use plain::Plain;
use libbpf_rs::OpenObject;
use libbpf_rs::ProgramInput;
use libc::{pthread_self, pthread_setschedparam, sched_param};
#[cfg(target_env = "musl")]
use libc::timespec;
use scx_utils::compat;
use scx_utils::scx_ops_attach;
use scx_utils::scx_ops_load;
use scx_utils::scx_ops_open;
use scx_utils::uei_exited;
use scx_utils::uei_report;
use scx_utils::Topology;
use scx_utils::UserExitInfo;
use scx_rustland_core::ALLOCATOR;
// Defined in UAPI
const SCHED_EXT: i32 = 7;
// Allow to dispatch the task on any CPU.
//
// The task will be dispatched to the global shared DSQ and it will run on the first CPU available.
#[allow(dead_code)]
pub const RL_CPU_ANY: i32 = bpf_intf::RL_CPU_ANY as i32;
/// High-level Rust abstraction to interact with a generic sched-ext BPF component.
///
/// Overview
/// ========
///
/// The main BPF interface is provided by the BpfScheduler() struct. When this object is
/// initialized it will take care of registering and initializing the BPF component.
///
/// The scheduler then can use BpfScheduler() instance to receive tasks (in the form of QueuedTask
/// objects) and dispatch tasks (in the form of DispatchedTask objects), using respectively the
/// methods dequeue_task() and dispatch_task().
///
/// BPF counters and statistics can be accessed using the methods nr_*_mut(), in particular
/// nr_queued_mut() and nr_scheduled_mut() can be updated to notify the BPF component if the
/// user-space scheduler has some pending work to do or not.
///
/// Finally the methods exited() and shutdown_and_report() can be used respectively to test
/// whether the BPF component exited, and to shutdown and report the exit message.
// Task queued for scheduling from the BPF component (see bpf_intf::queued_task_ctx).
#[derive(Debug, PartialEq, Eq, PartialOrd, Clone)]
pub struct QueuedTask {
pub pid: i32, // pid that uniquely identifies a task
pub cpu: i32, // CPU where the task is running
pub flags: u64, // task enqueue flags
pub exec_runtime: u64, // Total cpu time since last sleep
pub sum_exec_runtime: u64, // Total cpu time
pub nvcsw: u64, // Total amount of voluntary context switches
pub weight: u64, // Task static priority
pub slice: u64, // Time slice budget
pub vtime: u64, // Current vruntime
cpumask_cnt: u64, // cpumask generation counter (private)
}
// Task queued for dispatching to the BPF component (see bpf_intf::dispatched_task_ctx).
#[derive(Debug, PartialEq, Eq, PartialOrd, Clone)]
pub struct DispatchedTask {
pub pid: i32, // pid that uniquely identifies a task
pub cpu: i32, // target CPU selected by the scheduler
pub flags: u64, // special dispatch flags
pub slice_ns: u64, // time slice assigned to the task (0 = default)
pub vtime: u64, // task deadline / vruntime
cpumask_cnt: u64, // cpumask generation counter (private)
}
impl DispatchedTask {
// Create a DispatchedTask from a QueuedTask.
//
// A dispatched task should be always originated from a QueuedTask (there is no reason to
// dispatch a task if it wasn't queued to the scheduler earlier).
pub fn new(task: &QueuedTask) -> Self {
DispatchedTask {
pid: task.pid,
cpu: task.cpu,
flags: task.flags,
slice_ns: 0, // use default time slice
vtime: 0,
cpumask_cnt: task.cpumask_cnt,
}
}
}
// Helpers used to submit tasks to the BPF user ring buffer.
unsafe impl Plain for bpf_intf::dispatched_task_ctx {}
impl AsMut for bpf_intf::dispatched_task_ctx {
fn as_mut(&mut self) -> &mut bpf_intf::dispatched_task_ctx {
self
}
}
// Message received from the dispatcher (see bpf_intf::queued_task_ctx for details).
//
// NOTE: eventually libbpf-rs will provide a better abstraction for this.
struct EnqueuedMessage {
inner: bpf_intf::queued_task_ctx,
}
impl EnqueuedMessage {
fn from_bytes(bytes: &[u8]) -> Self {
let queued_task_struct = unsafe { *(bytes.as_ptr() as *const bpf_intf::queued_task_ctx) };
EnqueuedMessage {
inner: queued_task_struct,
}
}
fn to_queued_task(&self) -> QueuedTask {
QueuedTask {
pid: self.inner.pid,
cpu: self.inner.cpu,
flags: self.inner.flags,
exec_runtime: self.inner.exec_runtime,
sum_exec_runtime: self.inner.sum_exec_runtime,
nvcsw: self.inner.nvcsw,
weight: self.inner.weight,
slice: self.inner.slice,
vtime: self.inner.vtime,
cpumask_cnt: self.inner.cpumask_cnt,
}
}
}
pub struct BpfScheduler<'cb> {
pub skel: BpfSkel<'cb>, // Low-level BPF connector
shutdown: Arc, // Determine scheduler shutdown
queued: libbpf_rs::RingBuffer<'cb>, // Ring buffer of queued tasks
dispatched: libbpf_rs::UserRingBuffer, // User Ring buffer of dispatched tasks
struct_ops: Option, // Low-level BPF methods
}
// Buffer to store a task read from the ring buffer.
//
// NOTE: make the buffer aligned to 64-bits to prevent misaligned dereferences when accessing the
// buffer using a pointer.
const BUFSIZE: usize = std::mem::size_of::();
#[repr(align(8))]
struct AlignedBuffer([u8; BUFSIZE]);
static mut BUF: AlignedBuffer = AlignedBuffer([0; BUFSIZE]);
// Special negative error code for libbpf to stop after consuming just one item from a BPF
// ring buffer.
const LIBBPF_STOP: i32 = -255;
static SET_HANDLER: Once = Once::new();
fn set_ctrlc_handler(shutdown: Arc) -> Result<(), anyhow::Error> {
SET_HANDLER.call_once(|| {
let shutdown_clone = shutdown.clone();
ctrlc::set_handler(move || {
shutdown_clone.store(true, Ordering::Relaxed);
}).expect("Error setting Ctrl-C handler");
});
Ok(())
}
impl<'cb> BpfScheduler<'cb> {
pub fn init(
open_object: &'cb mut MaybeUninit,
exit_dump_len: u32,
partial: bool,
debug: bool,
builtin_idle: bool,
) -> Result {
let shutdown = Arc::new(AtomicBool::new(false));
set_ctrlc_handler(shutdown.clone()).context("Error setting Ctrl-C handler")?;
// Open the BPF prog first for verification.
let mut skel_builder = BpfSkelBuilder::default();
skel_builder.obj_builder.debug(debug);
let mut skel = scx_ops_open!(skel_builder, open_object, rustland)?;
// Copy one item from the ring buffer.
//
// # Safety
//
// Each invocation of the callback will trigger the copy of exactly one QueuedTask item to
// BUF. The caller must be synchronize to ensure that multiple invocations of the callback
// are not happening at the same time, but this is implicitly guaranteed by the fact that
// the caller is a single-thread process (for now).
//
// Use of a `str` whose contents are not valid UTF-8 is undefined behavior.
fn callback(data: &[u8]) -> i32 {
#[allow(static_mut_refs)]
unsafe {
// SAFETY: copying from the BPF ring buffer to BUF is safe, since the size of BUF
// is exactly the size of QueuedTask and the callback operates in chunks of
// QueuedTask items. It also copies exactly one QueuedTask at a time, this is
// guaranteed by the error code returned by this callback (see below). From a
// thread-safety perspective this is also correct, assuming the caller is a
// single-thread process (as it is for now).
BUF.0.copy_from_slice(data);
}
// Return an unsupported error to stop early and consume only one item.
//
// NOTE: this is quite a hack. I wish libbpf would honor stopping after the first item
// is consumed, upon returning a non-zero positive value here, but it doesn't seem to
// be the case:
//
// https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/tools/lib/bpf/ringbuf.c?h=v6.8-rc5#n260
//
// Maybe we should fix this to stop processing items from the ring buffer also when a
// value > 0 is returned.
//
LIBBPF_STOP
}
// Check host topology to determine if we need to enable SMT capabilities.
let topo = Topology::new().unwrap();
skel.maps.rodata_data.smt_enabled = topo.smt_enabled;
// Enable optional scheduler settings.
skel.struct_ops.rustland_mut().flags |=
*compat::SCX_OPS_ALLOW_QUEUED_WAKEUP | *compat::SCX_OPS_ENQ_MIGRATION_DISABLED;
if partial {
skel.struct_ops.rustland_mut().flags |= *compat::SCX_OPS_SWITCH_PARTIAL;
}
skel.struct_ops.rustland_mut().exit_dump_len = exit_dump_len;
skel.maps.bss_data.usersched_pid = std::process::id();
skel.maps.rodata_data.builtin_idle = builtin_idle;
skel.maps.rodata_data.debug = debug;
// Attach BPF scheduler.
let mut skel = scx_ops_load!(skel, rustland, uei)?;
// Initialize cache domains.
Self::init_l2_cache_domains(&mut skel, &topo)?;
Self::init_l3_cache_domains(&mut skel, &topo)?;
let struct_ops = Some(scx_ops_attach!(skel, rustland)?);
// Build the ring buffer of queued tasks.
let maps = &skel.maps;
let queued_ring_buffer = &maps.queued;
let mut rbb = libbpf_rs::RingBufferBuilder::new();
rbb.add(queued_ring_buffer, callback)
.expect("failed to add ringbuf callback");
let queued = rbb.build().expect("failed to build ringbuf");
// Build the user ring buffer of dispatched tasks.
let dispatched = libbpf_rs::UserRingBuffer::new(&maps.dispatched)
.expect("failed to create user ringbuf");
// Lock all the memory to prevent page faults that could trigger potential deadlocks during
// scheduling.
ALLOCATOR.lock_memory();
ALLOCATOR.disable_mmap().expect("Failed to disable mmap");
// Make sure to use the SCHED_EXT class at least for the scheduler itself.
match Self::use_sched_ext() {
0 => Ok(Self {
skel,
shutdown,
queued,
dispatched,
struct_ops,
}),
err => Err(anyhow::Error::msg(format!(
"sched_setscheduler error: {}",
err
))),
}
}
fn enable_sibling_cpu(
skel: &mut BpfSkel<'_>,
lvl: usize,
cpu: usize,
sibling_cpu: usize,
) -> Result<(), u32> {
let prog = &mut skel.progs.enable_sibling_cpu;
let mut args = domain_arg {
lvl_id: lvl as c_int,
cpu_id: cpu as c_int,
sibling_cpu_id: sibling_cpu as c_int,
};
let input = ProgramInput {
context_in: Some(unsafe {
std::slice::from_raw_parts_mut(
&mut args as *mut _ as *mut u8,
std::mem::size_of_val(&args),
)
}),
..Default::default()
};
let out = prog.test_run(input).unwrap();
if out.return_value != 0 {
return Err(out.return_value);
}
Ok(())
}
fn init_cache_domains(
skel: &mut BpfSkel<'_>,
topo: &Topology,
cache_lvl: usize,
enable_sibling_cpu_fn: &SiblingCpuFn,
) -> Result<(), std::io::Error>
where SiblingCpuFn: Fn(&mut BpfSkel<'_>, usize, usize, usize) -> Result<(), u32>
{
// Determine the list of CPU IDs associated to each cache node.
let mut cache_id_map: HashMap> = HashMap::new();
for core in topo.all_cores.values() {
for (cpu_id, cpu) in &core.cpus {
let cache_id = match cache_lvl {
2 => cpu.l2_id,
3 => cpu.l3_id,
_ => panic!("invalid cache level {}", cache_lvl),
};
cache_id_map
.entry(cache_id)
.or_insert_with(Vec::new)
.push(*cpu_id);
}
}
// Update the BPF cpumasks for the cache domains.
for (_cache_id, cpus) in cache_id_map {
for cpu in &cpus {
for sibling_cpu in &cpus {
match enable_sibling_cpu_fn(skel, cache_lvl, *cpu, *sibling_cpu) {
Ok(()) => {}
Err(_) => {}
}
}
}
}
Ok(())
}
fn init_l2_cache_domains(
skel: &mut BpfSkel<'_>,
topo: &Topology,
) -> Result<(), std::io::Error> {
Self::init_cache_domains(skel, topo, 2, &|skel, lvl, cpu, sibling_cpu| {
Self::enable_sibling_cpu(skel, lvl, cpu, sibling_cpu)
})
}
fn init_l3_cache_domains(
skel: &mut BpfSkel<'_>,
topo: &Topology,
) -> Result<(), std::io::Error> {
Self::init_cache_domains(skel, topo, 3, &|skel, lvl, cpu, sibling_cpu| {
Self::enable_sibling_cpu(skel, lvl, cpu, sibling_cpu)
})
}
// Notify the BPF component that the user-space scheduler has completed its scheduling cycle,
// updating the amount tasks that are still pending.
//
// NOTE: do not set allow(dead_code) for this method, any scheduler must use this method at
// some point, otherwise the BPF component will keep waking-up the user-space scheduler in a
// busy loop, causing unnecessary high CPU consumption.
pub fn notify_complete(&mut self, nr_pending: u64) {
self.skel.maps.bss_data.nr_scheduled = nr_pending;
std::thread::yield_now();
}
// Counter of the online CPUs.
#[allow(dead_code)]
pub fn nr_online_cpus_mut(&mut self) -> &mut u64 {
&mut self.skel.maps.bss_data.nr_online_cpus
}
// Counter of currently running tasks.
#[allow(dead_code)]
pub fn nr_running_mut(&mut self) -> &mut u64 {
&mut self.skel.maps.bss_data.nr_running
}
// Counter of queued tasks.
#[allow(dead_code)]
pub fn nr_queued_mut(&mut self) -> &mut u64 {
&mut self.skel.maps.bss_data.nr_queued
}
// Counter of scheduled tasks.
#[allow(dead_code)]
pub fn nr_scheduled_mut(&mut self) -> &mut u64 {
&mut self.skel.maps.bss_data.nr_scheduled
}
// Counter of user dispatch events.
#[allow(dead_code)]
pub fn nr_user_dispatches_mut(&mut self) -> &mut u64 {
&mut self.skel.maps.bss_data.nr_user_dispatches
}
// Counter of user kernel events.
#[allow(dead_code)]
pub fn nr_kernel_dispatches_mut(&mut self) -> &mut u64 {
&mut self.skel.maps.bss_data.nr_kernel_dispatches
}
// Counter of cancel dispatch events.
#[allow(dead_code)]
pub fn nr_cancel_dispatches_mut(&mut self) -> &mut u64 {
&mut self.skel.maps.bss_data.nr_cancel_dispatches
}
// Counter of dispatches bounced to the shared DSQ.
#[allow(dead_code)]
pub fn nr_bounce_dispatches_mut(&mut self) -> &mut u64 {
&mut self.skel.maps.bss_data.nr_bounce_dispatches
}
// Counter of failed dispatch events.
#[allow(dead_code)]
pub fn nr_failed_dispatches_mut(&mut self) -> &mut u64 {
&mut self.skel.maps.bss_data.nr_failed_dispatches
}
// Counter of scheduler congestion events.
#[allow(dead_code)]
pub fn nr_sched_congested_mut(&mut self) -> &mut u64 {
&mut self.skel.maps.bss_data.nr_sched_congested
}
// Set scheduling class for the scheduler itself to SCHED_EXT
fn use_sched_ext() -> i32 {
#[cfg(target_env = "gnu")]
let param: sched_param = sched_param { sched_priority: 0 };
#[cfg(target_env = "musl")]
let param: sched_param = sched_param {
sched_priority: 0,
sched_ss_low_priority: 0,
sched_ss_repl_period: timespec {
tv_sec: 0,
tv_nsec: 0,
},
sched_ss_init_budget: timespec {
tv_sec: 0,
tv_nsec: 0,
},
sched_ss_max_repl: 0,
};
unsafe { pthread_setschedparam(pthread_self(), SCHED_EXT, ¶m as *const sched_param) }
}
// Pick an idle CPU for the target PID.
pub fn select_cpu(&mut self, pid: i32, cpu: i32, flags: u64) -> i32 {
let prog = &mut self.skel.progs.rs_select_cpu;
let mut args = task_cpu_arg {
pid: pid as c_int,
cpu: cpu as c_int,
flags: flags as c_ulong,
};
let input = ProgramInput {
context_in: Some(unsafe {
std::slice::from_raw_parts_mut(
&mut args as *mut _ as *mut u8,
std::mem::size_of_val(&args),
)
}),
..Default::default()
};
let out = prog.test_run(input).unwrap();
out.return_value as i32
}
// Receive a task to be scheduled from the BPF dispatcher.
#[allow(static_mut_refs)]
pub fn dequeue_task(&mut self) -> Result, i32> {
match self.queued.consume_raw() {
0 => {
self.skel.maps.bss_data.nr_queued = 0;
Ok(None)
}
LIBBPF_STOP => {
// A valid task is received, convert data to a proper task struct.
let task = unsafe { EnqueuedMessage::from_bytes(&BUF.0).to_queued_task() };
self.skel.maps.bss_data.nr_queued = self.skel.maps.bss_data.nr_queued.saturating_sub(1);
Ok(Some(task))
}
res if res < 0 => Err(res),
res => panic!(
"Unexpected return value from libbpf-rs::consume_raw(): {}",
res
),
}
}
// Send a task to the dispatcher.
pub fn dispatch_task(&mut self, task: &DispatchedTask) -> Result<(), libbpf_rs::Error> {
// Reserve a slot in the user ring buffer.
let mut urb_sample = self
.dispatched
.reserve(std::mem::size_of::())?;
let bytes = urb_sample.as_mut();
let dispatched_task = plain::from_mut_bytes::(bytes)
.expect("failed to convert bytes");
// Convert the dispatched task into the low-level dispatched task context.
let bpf_intf::dispatched_task_ctx {
pid,
cpu,
flags,
slice_ns,
vtime,
cpumask_cnt,
..
} = &mut dispatched_task.as_mut();
*pid = task.pid;
*cpu = task.cpu;
*flags = task.flags;
*slice_ns = task.slice_ns;
*vtime = task.vtime;
*cpumask_cnt = task.cpumask_cnt;
// Store the task in the user ring buffer.
//
// NOTE: submit() only updates the reserved slot in the user ring buffer, so it is not
// expected to fail.
self.dispatched
.submit(urb_sample)
.expect("failed to submit task");
Ok(())
}
// Read exit code from the BPF part.
pub fn exited(&mut self) -> bool {
self.shutdown.load(Ordering::Relaxed) || uei_exited!(&self.skel, uei)
}
// Called on exit to shutdown and report exit message from the BPF part.
pub fn shutdown_and_report(&mut self) -> Result {
self.struct_ops.take();
uei_report!(&self.skel, uei)
}
}
// Disconnect the low-level BPF scheduler.
impl Drop for BpfScheduler<'_> {
fn drop(&mut self) {
if let Some(struct_ops) = self.struct_ops.take() {
drop(struct_ops);
}
ALLOCATOR.unlock_memory();
}
}
scx-1.0.12/rust/scx_rustland_core/assets/bpf/ 0000775 0000000 0000000 00000000000 15007705772 0021171 5 ustar 00root root 0000000 0000000 scx-1.0.12/rust/scx_rustland_core/assets/bpf/intf.h 0000664 0000000 0000000 00000005152 15007705772 0022305 0 ustar 00root root 0000000 0000000 // This software may be used and distributed according to the terms of the
// GNU General Public License version 2.
#ifndef __INTF_H
#define __INTF_H
#define MAX(x, y) ((x) > (y) ? (x) : (y))
#define MIN(x, y) ((x) < (y) ? (x) : (y))
#define NSEC_PER_SEC 1000000000L
#define CLOCK_BOOTTIME 7
#include
#ifndef __kptr
#ifdef __KERNEL__
#error "__kptr_ref not defined in the kernel"
#endif
#define __kptr
#endif
#ifndef __VMLINUX_H__
typedef unsigned char u8;
typedef unsigned short u16;
typedef unsigned int u32;
typedef unsigned long u64;
typedef signed char s8;
typedef signed short s16;
typedef signed int s32;
typedef signed long s64;
typedef int pid_t;
#endif /* __VMLINUX_H__ */
/* Check a condition at build time */
#define BUILD_BUG_ON(expr) \
do { \
extern char __build_assert__[(expr) ? -1 : 1] \
__attribute__((unused)); \
} while(0)
/*
* Maximum amount of CPUs supported by this scheduler (this defines the size of
* cpu_map that is used to store the idle state and CPU ownership).
*/
#define MAX_CPUS 1024
/* Special dispatch flags */
enum {
/*
* Do not assign any specific CPU to the task.
*
* The task will be dispatched to the global shared DSQ and it will run
* on the first CPU available.
*/
RL_CPU_ANY = 1 << 20,
};
/*
* Specify a target CPU for a specific PID.
*/
struct task_cpu_arg {
pid_t pid;
s32 cpu;
u64 flags;
};
/*
* Specify a sibling CPU relationship for a specific scheduling domain.
*/
struct domain_arg {
s32 lvl_id;
s32 cpu_id;
s32 sibling_cpu_id;
};
/*
* Task sent to the user-space scheduler by the BPF dispatcher.
*
* All attributes are collected from the kernel by the the BPF component.
*/
struct queued_task_ctx {
s32 pid;
s32 cpu; /* CPU where the task is running */
u64 flags; /* task enqueue flags */
u64 exec_runtime; /* Total cpu time since last sleep */
u64 sum_exec_runtime; /* Total cpu time */
u64 nvcsw; /* Total amount of voluntary context switches */
u64 weight; /* Task static priority */
u64 slice; /* Time slice budget */
u64 vtime; /* Current task's vruntime */
u64 cpumask_cnt; /* cpumask generation counter */
};
/*
* Task sent to the BPF dispatcher by the user-space scheduler.
*
* This struct can be easily extended to send more information to the
* dispatcher (i.e., a target CPU, a variable time slice, etc.).
*/
struct dispatched_task_ctx {
s32 pid;
s32 cpu; /* CPU where the task should be dispatched */
u64 flags; /* task enqueue flags */
u64 slice_ns; /* time slice assigned to the task (0=default) */
u64 vtime; /* task deadline / vruntime */
u64 cpumask_cnt; /* cpumask generation counter */
};
#endif /* __INTF_H */
scx-1.0.12/rust/scx_rustland_core/assets/bpf/main.bpf.c 0000664 0000000 0000000 00000101556 15007705772 0023037 0 ustar 00root root 0000000 0000000 /* Copyright (c) Andrea Righi */
/*
* scx_rustland_core: BPF backend for schedulers running in user-space.
*
* This BPF backend implements the low level sched-ext functionalities for a
* user-space counterpart, that implements the actual scheduling policy.
*
* The BPF part collects total cputime and weight from the tasks that need to
* run, then it sends all details to the user-space scheduler that decides the
* best order of execution of the tasks (based on the collected metrics).
*
* The user-space scheduler then returns to the BPF component the list of tasks
* to be dispatched in the proper order.
*
* Messages between the BPF component and the user-space scheduler are passed
* using BPF_MAP_TYPE_RINGBUFFER / BPF_MAP_TYPE_USER_RINGBUF maps: @queued for
* the messages sent by the BPF dispatcher to the user-space scheduler and
* @dispatched for the messages sent by the user-space scheduler to the BPF
* dispatcher.
*
* The BPF dispatcher is completely agnostic of the particular scheduling
* policy implemented in user-space. For this reason developers that are
* willing to use this scheduler to experiment scheduling policies should be
* able to simply modify the Rust component, without having to deal with any
* internal kernel / BPF details.
*
* This software may be used and distributed according to the terms of the
* GNU General Public License version 2.
*/
#ifdef LSP
#define __bpf__
#include "../../../../scheds/include/scx/common.bpf.h"
#else
#include
#endif
#include "intf.h"
char _license[] SEC("license") = "GPL";
UEI_DEFINE(uei);
/*
* Introduce a custom DSQ shared across all the CPUs, where we can dispatch
* tasks that will be executed on the first CPU available.
*
* Per-CPU DSQs are also provided, to allow the scheduler to run a task on a
* specific CPU (see dsq_init()).
*/
#define SHARED_DSQ MAX_CPUS
/*
* Scheduler attributes and statistics.
*/
u32 usersched_pid; /* User-space scheduler PID */
u64 usersched_last_run_at; /* Timestamp of the last user-space scheduler execution */
const volatile bool switch_partial; /* Switch all tasks or SCHED_EXT tasks */
/*
* Number of tasks that are queued for scheduling.
*
* This number is incremented by the BPF component when a task is queued to the
* user-space scheduler and it must be decremented by the user-space scheduler
* when a task is consumed.
*/
volatile u64 nr_queued;
/*
* Number of tasks that are waiting for scheduling.
*
* This number must be updated by the user-space scheduler to keep track if
* there is still some scheduling work to do.
*/
volatile u64 nr_scheduled;
/*
* Amount of currently running tasks.
*/
volatile u64 nr_running, nr_online_cpus;
/* Dispatch statistics */
volatile u64 nr_user_dispatches, nr_kernel_dispatches,
nr_cancel_dispatches, nr_bounce_dispatches;
/* Failure statistics */
volatile u64 nr_failed_dispatches, nr_sched_congested;
/* Report additional debugging information */
const volatile bool debug;
/* Rely on the in-kernel idle CPU selection policy */
const volatile bool builtin_idle;
/* Allow to use bpf_printk() only when @debug is set */
#define dbg_msg(_fmt, ...) do { \
if (debug) \
bpf_printk(_fmt, ##__VA_ARGS__); \
} while(0)
/*
* CPUs in the system have SMT is enabled.
*/
const volatile bool smt_enabled = true;
/*
* Allocate/re-allocate a new cpumask.
*/
static int calloc_cpumask(struct bpf_cpumask **p_cpumask)
{
struct bpf_cpumask *cpumask;
cpumask = bpf_cpumask_create();
if (!cpumask)
return -ENOMEM;
cpumask = bpf_kptr_xchg(p_cpumask, cpumask);
if (cpumask)
bpf_cpumask_release(cpumask);
return 0;
}
/*
* Maximum amount of tasks queued between kernel and user-space at a certain
* time.
*
* The @queued and @dispatched lists are used in a producer/consumer fashion
* between the BPF part and the user-space part.
*/
#define MAX_ENQUEUED_TASKS 4096
/*
* Maximum amount of slots reserved to the tasks dispatched via shared queue.
*/
#define MAX_DISPATCH_SLOT (MAX_ENQUEUED_TASKS / 8)
/*
* The map containing tasks that are queued to user space from the kernel.
*
* This map is drained by the user space scheduler.
*/
struct {
__uint(type, BPF_MAP_TYPE_RINGBUF);
__uint(max_entries, MAX_ENQUEUED_TASKS *
sizeof(struct queued_task_ctx));
} queued SEC(".maps");
/*
* The user ring buffer containing pids that are dispatched from user space to
* the kernel.
*
* Drained by the kernel in .dispatch().
*/
struct {
__uint(type, BPF_MAP_TYPE_USER_RINGBUF);
__uint(max_entries, MAX_ENQUEUED_TASKS *
sizeof(struct dispatched_task_ctx));
} dispatched SEC(".maps");
/*
* Per-CPU context.
*/
struct cpu_ctx {
struct bpf_cpumask __kptr *l2_cpumask;
struct bpf_cpumask __kptr *l3_cpumask;
};
struct {
__uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
__type(key, u32);
__type(value, struct cpu_ctx);
__uint(max_entries, 1);
} cpu_ctx_stor SEC(".maps");
/*
* Return a CPU context.
*/
struct cpu_ctx *try_lookup_cpu_ctx(s32 cpu)
{
const u32 idx = 0;
return bpf_map_lookup_percpu_elem(&cpu_ctx_stor, &idx, cpu);
}
/*
* Per-task local storage.
*
* This contain all the per-task information used internally by the BPF code.
*/
struct task_ctx {
/*
* Temporary cpumask for calculating scheduling domains.
*/
struct bpf_cpumask __kptr *l2_cpumask;
struct bpf_cpumask __kptr *l3_cpumask;
/*
* Timestamp since last time the task ran on a CPU.
*/
u64 last_run_at;
/*
* Execution time (in nanoseconds) since the last sleep event.
*/
u64 exec_runtime;
/*
* cpumask generation counter: used to verify the validity of the
* current task's cpumask.
*/
u64 cpumask_cnt;
};
/* Map that contains task-local storage. */
struct {
__uint(type, BPF_MAP_TYPE_TASK_STORAGE);
__uint(map_flags, BPF_F_NO_PREALLOC);
__type(key, int);
__type(value, struct task_ctx);
} task_ctx_stor SEC(".maps");
/*
* Return a local task context from a generic task or NULL if the context
* doesn't exist.
*/
struct task_ctx *try_lookup_task_ctx(const struct task_struct *p)
{
struct task_ctx *tctx = bpf_task_storage_get(&task_ctx_stor,
(struct task_struct *)p, 0, 0);
if (!tctx)
dbg_msg("warning: failed to get task context for pid=%d (%s)",
p->pid, p->comm);
return tctx;
}
/*
* Heartbeat timer used to periodically trigger the check to run the user-space
* scheduler.
*
* Without this timer we may starve the scheduler if the system is completely
* idle and hit the watchdog that would auto-kill this scheduler.
*/
struct usersched_timer {
struct bpf_timer timer;
};
struct {
__uint(type, BPF_MAP_TYPE_ARRAY);
__uint(max_entries, 1);
__type(key, u32);
__type(value, struct usersched_timer);
} usersched_timer SEC(".maps");
/*
* Time period of the scheduler heartbeat, used to periodically kick the
* user-space scheduler and check if there is any pending activity.
*/
#define USERSCHED_TIMER_NS (NSEC_PER_SEC / 10)
/*
* Return true if the target task @p is the user-space scheduler.
*/
static inline bool is_usersched_task(const struct task_struct *p)
{
return p->pid == usersched_pid;
}
/*
* Return true if the target task @p is a kernel thread.
*/
static inline bool is_kthread(const struct task_struct *p)
{
return p->flags & PF_KTHREAD;
}
/*
* Return true if @p still wants to run, false otherwise.
*/
static bool is_queued(const struct task_struct *p)
{
return p->scx.flags & SCX_TASK_QUEUED;
}
/*
* Flag used to wake-up the user-space scheduler.
*/
static volatile u32 usersched_needed;
/*
* Set user-space scheduler wake-up flag (equivalent to an atomic release
* operation).
*/
static void set_usersched_needed(void)
{
__sync_fetch_and_or(&usersched_needed, 1);
}
/*
* Check and clear user-space scheduler wake-up flag (equivalent to an atomic
* acquire operation).
*/
static bool test_and_clear_usersched_needed(void)
{
return __sync_fetch_and_and(&usersched_needed, 0) == 1;
}
/*
* Return true if there's any pending activity to do for the scheduler, false
* otherwise.
*
* NOTE: a task is sent to the user-space scheduler using the "queued"
* ringbuffer, then the scheduler drains the queued tasks and adds them to
* its internal data structures / state; at this point tasks become
* "scheduled" and the user-space scheduler will take care of updating
* nr_scheduled accordingly; lastly tasks will be dispatched and the
* user-space scheduler will update nr_scheduled again.
*
* Checking nr_scheduled and the available data in the ringbuffer allows to
* determine if there is still some pending work to do for the scheduler:
* new tasks have been queued since last check, or there are still tasks
* "queued" or "scheduled" since the previous user-space scheduler run.
*
* If there's no pending action, it is pointless to wake-up the scheduler
* (even if a CPU becomes idle), because there is nothing to do.
*
* Also keep in mind that we don't need any protection here since this code
* doesn't run concurrently with the user-space scheduler (that is single
* threaded), therefore this check is also safe from a concurrency perspective.
*/
static bool usersched_has_pending_tasks(void)
{
if (nr_scheduled)
return true;
return bpf_ringbuf_query(&queued, BPF_RB_AVAIL_DATA) > 0;
}
/*
* Return the DSQ ID associated to a CPU, or SHARED_DSQ if the CPU is not
* valid.
*/
static u64 cpu_to_dsq(s32 cpu)
{
if (cpu < 0 || cpu >= MAX_CPUS) {
scx_bpf_error("Invalid cpu: %d", cpu);
return SHARED_DSQ;
}
return (u64)cpu;
}
/*
* Find an idle CPU in the system for the task.
*
* NOTE: the idle CPU selection doesn't need to be formally perfect, it is
* totally fine to accept racy conditions and potentially make mistakes, by
* picking CPUs that are not idle or even offline, the logic has been designed
* to handle these mistakes in favor of a more efficient response and a reduced
* scheduling overhead.
*/
static s32 pick_idle_cpu(struct task_struct *p, s32 prev_cpu)
{
const struct cpumask *online_cpumask, *idle_smtmask, *idle_cpumask;
struct bpf_cpumask *l2_domain, *l3_domain;
struct bpf_cpumask *l2_mask, *l3_mask;
struct task_ctx *tctx;
struct cpu_ctx *cctx;
s32 cpu;
/*
* If the task isn't allowed to use its previously used CPU it means
* that it's rapidly changing affinity. In this case it's pointless to
* find an optimal idle CPU, just return any idle CPU.
*/
if (!bpf_cpumask_test_cpu(prev_cpu, p->cpus_ptr))
return scx_bpf_pick_idle_cpu(p->cpus_ptr, 0);
/*
* For tasks that can run only on a single CPU, we can simply verify if
* their only allowed CPU is still idle.
*/
if (p->nr_cpus_allowed == 1 || is_migration_disabled(p)) {
if (scx_bpf_test_and_clear_cpu_idle(prev_cpu))
return prev_cpu;
return -ENOENT;
}
tctx = try_lookup_task_ctx(p);
if (!tctx)
return -ENOENT;
cctx = try_lookup_cpu_ctx(prev_cpu);
if (!cctx)
return -ENOENT;
/*
* Acquire the CPU masks to determine the online and idle CPUs in the
* system.
*/
online_cpumask = scx_bpf_get_online_cpumask();
idle_smtmask = scx_bpf_get_idle_smtmask();
idle_cpumask = scx_bpf_get_idle_cpumask();
/*
* Scheduling domains of the previously used CPU.
*/
l2_domain = cctx->l2_cpumask;
if (!l2_domain)
l2_domain = (struct bpf_cpumask *)p->cpus_ptr;
l3_domain = cctx->l3_cpumask;
if (!l3_domain)
l3_domain = (struct bpf_cpumask *)p->cpus_ptr;
/*
* Task's scheduling domains.
*/
l2_mask = tctx->l2_cpumask;
if (!l2_mask) {
scx_bpf_error("l2 cpumask not initialized");
cpu = -ENOENT;
goto out_put_cpumask;
}
l3_mask = tctx->l3_cpumask;
if (!l3_mask) {
scx_bpf_error("l3 cpumask not initialized");
cpu = -ENOENT;
goto out_put_cpumask;
}
/*
* Determine the L2 cache domain as the intersection of the task's
* primary cpumask and the L2 cache domain mask of the previously used
* CPU (ignore if this cpumask completely overlaps with the task's
* cpumask).
*/
bpf_cpumask_and(l2_mask, p->cpus_ptr, cast_mask(l2_domain));
/*
* Determine the L3 cache domain as the intersection of the task's
* primary cpumask and the L3 cache domain mask of the previously used
* CPU (ignore if this cpumask completely overlaps with the task's
* cpumask).
*/
bpf_cpumask_and(l3_mask, p->cpus_ptr, cast_mask(l3_domain));
/*
* Find the best idle CPU, prioritizing full idle cores in SMT systems.
*/
if (smt_enabled) {
/*
* If the task can still run on the previously used CPU and
* it's a full-idle core, keep using it.
*/
if (bpf_cpumask_test_cpu(prev_cpu, p->cpus_ptr) &&
bpf_cpumask_test_cpu(prev_cpu, idle_smtmask) &&
scx_bpf_test_and_clear_cpu_idle(prev_cpu)) {
cpu = prev_cpu;
goto out_put_cpumask;
}
/*
* Search for any full-idle CPU in the task domain that shares
* the same L2 cache.
*/
cpu = bpf_cpumask_any_and_distribute(cast_mask(l2_mask), idle_smtmask);
if (bpf_cpumask_test_cpu(cpu, online_cpumask) &&
scx_bpf_test_and_clear_cpu_idle(cpu))
goto out_put_cpumask;
/*
* Search for any full-idle CPU in the task domain that shares
* the same L3 cache.
*/
cpu = bpf_cpumask_any_and_distribute(cast_mask(l3_mask), idle_smtmask);
if (bpf_cpumask_test_cpu(cpu, online_cpumask) &&
scx_bpf_test_and_clear_cpu_idle(cpu))
goto out_put_cpumask;
/*
* Otherwise, search for another usable full-idle core.
*/
cpu = bpf_cpumask_any_and_distribute(p->cpus_ptr, idle_smtmask);
if (bpf_cpumask_test_cpu(cpu, online_cpumask) &&
scx_bpf_test_and_clear_cpu_idle(cpu))
goto out_put_cpumask;
}
/*
* If a full-idle core can't be found (or if this is not an SMT system)
* try to re-use the same CPU, even if it's not in a full-idle core.
*/
if (bpf_cpumask_test_cpu(prev_cpu, p->cpus_ptr) &&
scx_bpf_test_and_clear_cpu_idle(prev_cpu)) {
cpu = prev_cpu;
goto out_put_cpumask;
}
/*
* Search for any idle CPU in the primary domain that shares the same
* L2 cache.
*/
cpu = bpf_cpumask_any_and_distribute(cast_mask(l2_mask), idle_cpumask);
if (bpf_cpumask_test_cpu(cpu, online_cpumask) &&
scx_bpf_test_and_clear_cpu_idle(cpu))
goto out_put_cpumask;
/*
* Search for any idle CPU in the primary domain that shares the same
* L3 cache.
*/
cpu = bpf_cpumask_any_and_distribute(cast_mask(l3_mask), idle_cpumask);
if (bpf_cpumask_test_cpu(cpu, online_cpumask) &&
scx_bpf_test_and_clear_cpu_idle(cpu))
goto out_put_cpumask;
/*
* If all the previous attempts have failed, try to use any idle CPU in
* the system.
*/
cpu = bpf_cpumask_any_and_distribute(p->cpus_ptr, idle_cpumask);
if (bpf_cpumask_test_cpu(cpu, online_cpumask) &&
scx_bpf_test_and_clear_cpu_idle(cpu))
goto out_put_cpumask;
/*
* If all the previous attempts have failed, dispatch the task to the
* first CPU that will become available.
*/
cpu = -ENOENT;
out_put_cpumask:
scx_bpf_put_cpumask(idle_cpumask);
scx_bpf_put_cpumask(idle_smtmask);
scx_bpf_put_cpumask(online_cpumask);
return cpu;
}
/*
* Dispatch a task to a target per-CPU DSQ, waking up the corresponding CPU, if
* needed.
*/
static void dispatch_task(const struct dispatched_task_ctx *task)
{
struct task_struct *p;
struct task_ctx *tctx;
u64 dsq_id, curr_cpumask_cnt;
s32 cpu;
/* Ignore entry if the task doesn't exist anymore */
p = bpf_task_from_pid(task->pid);
if (!p)
return;
/*
* Update task's time slice in its context.
*/
tctx = try_lookup_task_ctx(p);
if (!tctx)
goto out_release;
dbg_msg("dispatch: pid=%d (%s) cpu=0x%lx vtime=%llu slice=%llu",
p->pid, p->comm, task->cpu, task->vtime, task->slice_ns);
/*
* Dispatch task to the target DSQ.
*/
if (task->cpu == RL_CPU_ANY) {
scx_bpf_dsq_insert_vtime(p, SHARED_DSQ, task->slice_ns, task->vtime, task->flags);
goto out_kick_idle_cpu;
}
/* Read current cpumask generation counter */
curr_cpumask_cnt = tctx->cpumask_cnt;
/* Check if the CPU is valid, according to the cpumask */
if (!bpf_cpumask_test_cpu(task->cpu, p->cpus_ptr)) {
scx_bpf_dsq_insert_vtime(p, SHARED_DSQ, task->slice_ns, task->vtime, task->flags);
__sync_fetch_and_add(&nr_bounce_dispatches, 1);
goto out_kick_idle_cpu;
}
/*
* Dispatch a task to a specific per-CPU DSQ if the target CPU can be
* used (according to the cpumask), otherwise redirect the task to the
* shared DSQ.
*
* This can happen if the user-space scheduler dispatches the task to
* an invalid CPU. In this case the redirection to the shared DSQ
* allows to prevent potential stalls in the scheduler.
*
* If the cpumask is not valid anymore (determined by the cpumask_cnt
* generation counter) we can simply cancel the dispatch event, since
* the task will be re-enqueued by the core sched-ext code, potentially
* selecting a different cpu and a different cpumask.
*/
dsq_id = cpu_to_dsq(task->cpu);
/* Dispatch the task to the target per-CPU DSQ */
scx_bpf_dsq_insert_vtime(p, dsq_id, task->slice_ns, task->vtime, task->flags);
/* If the cpumask is not valid anymore, ignore the dispatch event */
if (curr_cpumask_cnt != task->cpumask_cnt) {
scx_bpf_dispatch_cancel();
__sync_fetch_and_add(&nr_cancel_dispatches, 1);
goto out_release;
}
if (task->cpu != bpf_get_smp_processor_id())
scx_bpf_kick_cpu(task->cpu, SCX_KICK_IDLE);
goto out_release;
out_kick_idle_cpu:
cpu = pick_idle_cpu(p, task->cpu);
if (cpu >= 0)
scx_bpf_kick_cpu(cpu, 0);
out_release:
bpf_task_release(p);
}
s32 BPF_STRUCT_OPS(rustland_select_cpu, struct task_struct *p, s32 prev_cpu,
u64 wake_flags)
{
bool is_idle = false;
s32 cpu;
/*
* If built-in idle CPU policy is not enabled completely delegate
* the idle selection policy to user-space and keep re-using the
* same CPU here.
*/
if (!builtin_idle || is_usersched_task(p))
return prev_cpu;
cpu = scx_bpf_select_cpu_dfl(p, prev_cpu, wake_flags, &is_idle);
if (is_idle && !scx_bpf_dsq_nr_queued(SHARED_DSQ)) {
scx_bpf_dsq_insert_vtime(p, cpu_to_dsq(cpu), SCX_SLICE_DFL, p->scx.dsq_vtime, 0);
__sync_fetch_and_add(&nr_kernel_dispatches, 1);
}
return cpu;
}
/*
* Select and wake-up an idle CPU for a specific task from the user-space
* scheduler.
*/
SEC("syscall")
int rs_select_cpu(struct task_cpu_arg *input)
{
struct task_struct *p;
int cpu;
p = bpf_task_from_pid(input->pid);
if (!p)
return -EINVAL;
bpf_rcu_read_lock();
cpu = pick_idle_cpu(p, input->cpu);
bpf_rcu_read_unlock();
bpf_task_release(p);
return cpu;
}
/*
* Fill @task with all the information that need to be sent to the user-space
* scheduler.
*/
static void get_task_info(struct queued_task_ctx *task,
const struct task_struct *p, u64 enq_flags)
{
struct task_ctx *tctx = try_lookup_task_ctx(p);
task->pid = p->pid;
task->cpu = scx_bpf_task_cpu(p);
task->flags = enq_flags;
task->exec_runtime = tctx ? tctx->exec_runtime : 0;
task->sum_exec_runtime = p->se.sum_exec_runtime;
task->nvcsw = p->nvcsw;
task->weight = p->scx.weight;
task->slice = p->scx.slice;
task->vtime = p->scx.dsq_vtime;
task->cpumask_cnt = tctx ? tctx->cpumask_cnt : 0;
}
/*
* User-space scheduler is congested: log that and increment congested counter.
*/
static void sched_congested(struct task_struct *p)
{
dbg_msg("congested: pid=%d (%s)", p->pid, p->comm);
__sync_fetch_and_add(&nr_sched_congested, 1);
}
/*
* Return true if a task has been enqueued as a remote wakeup, false
* otherwise.
*/
static bool is_queued_wakeup(const struct task_struct *p, u64 enq_flags)
{
return !__COMPAT_is_enq_cpu_selected(enq_flags) && !scx_bpf_task_running(p);
}
/*
* Task @p becomes ready to run. We can dispatch the task directly here if the
* user-space scheduler is not required, or enqueue it to be processed by the
* scheduler.
*/
void BPF_STRUCT_OPS(rustland_enqueue, struct task_struct *p, u64 enq_flags)
{
struct queued_task_ctx *task;
s32 cpu;
/*
* Scheduler is dispatched directly in .dispatch() when needed, so
* we can skip it here.
*/
if (is_usersched_task(p))
return;
/*
* Always dispatch per-CPU kthreads directly on their target CPU.
*
* This allows to prioritize critical kernel threads that may
* potentially stall the entire system if they are blocked for too long
* (i.e., ksoftirqd/N, rcuop/N, etc.).
*/
if (is_kthread(p) && p->nr_cpus_allowed == 1) {
scx_bpf_dsq_insert(p, SCX_DSQ_LOCAL, SCX_SLICE_DFL,
enq_flags | SCX_ENQ_PREEMPT);
__sync_fetch_and_add(&nr_kernel_dispatches, 1);
return;
}
/*
* Give the task a chance to be directly dispatched if
* ops.select_cpu() was skipped.
*/
if (builtin_idle && is_queued_wakeup(p, enq_flags)) {
s32 cpu = pick_idle_cpu(p, scx_bpf_task_cpu(p));
if (cpu >= 0) {
scx_bpf_dsq_insert_vtime(p, cpu_to_dsq(cpu),
SCX_SLICE_DFL, p->scx.dsq_vtime, enq_flags);
__sync_fetch_and_add(&nr_kernel_dispatches, 1);
scx_bpf_kick_cpu(cpu, SCX_KICK_IDLE);
return;
}
}
/*
* Add tasks to the @queued list, they will be processed by the
* user-space scheduler.
*
* If @queued list is full (user-space scheduler is congested) tasks
* will be dispatched directly from the kernel (using the first CPU
* available in this case).
*/
task = bpf_ringbuf_reserve(&queued, sizeof(*task), 0);
if (!task) {
sched_congested(p);
scx_bpf_dsq_insert_vtime(p, SHARED_DSQ, SCX_SLICE_DFL, p->scx.dsq_vtime, enq_flags);
__sync_fetch_and_add(&nr_kernel_dispatches, 1);
return;
}
get_task_info(task, p, enq_flags);
dbg_msg("enqueue: pid=%d (%s)", p->pid, p->comm);
bpf_ringbuf_submit(task, 0);
__sync_fetch_and_add(&nr_queued, 1);
cpu = scx_bpf_task_cpu(p);
if (cpu != bpf_get_smp_processor_id())
scx_bpf_kick_cpu(cpu, SCX_KICK_IDLE);
}
/*
* Dispatch the user-space scheduler.
*/
static bool dispatch_user_scheduler(void)
{
struct task_struct *p;
if (!test_and_clear_usersched_needed())
return false;
p = bpf_task_from_pid(usersched_pid);
if (!p) {
scx_bpf_error("Failed to find usersched task %d", usersched_pid);
return false;
}
/*
* Always append the user-space scheduler at the end of the shared
* DSQ, so that it'll run after all the tasks currently dispatched
* have used their assigned time slice on their target CPU.
*
* At the same time assign an infinite time slice, so that it can
* completely drain all the pending tasks.
*
* The user-space scheduler will voluntarily yield the CPU upon
* completion through BpfScheduler->notify_complete().
*/
scx_bpf_dsq_insert_vtime(p, SHARED_DSQ, SCX_SLICE_INF, -1ULL, 0);
bpf_task_release(p);
return true;
}
/*
* Handle a task dispatched from user-space, performing the actual low-level
* BPF dispatch.
*/
static long handle_dispatched_task(struct bpf_dynptr *dynptr, void *context)
{
const struct dispatched_task_ctx *task;
task = bpf_dynptr_data(dynptr, 0, sizeof(*task));
if (!task)
return 0;
dispatch_task(task);
__sync_fetch_and_add(&nr_user_dispatches, 1);
return !!scx_bpf_dispatch_nr_slots();
}
/*
* Dispatch tasks that are ready to run.
*
* This function is called when a CPU's local DSQ is empty and ready to accept
* new dispatched tasks.
*
* We may dispatch tasks also on other CPUs from here, if the scheduler decided
* so (usually if other CPUs are idle we may want to send more tasks to their
* local DSQ to optimize the scheduling pipeline).
*/
void BPF_STRUCT_OPS(rustland_dispatch, s32 cpu, struct task_struct *prev)
{
/*
* Consume all tasks from the @dispatched list and immediately dispatch
* them on the target CPU decided by the user-space scheduler.
*/
bpf_user_ringbuf_drain(&dispatched, handle_dispatched_task, NULL, 0);
/*
* Always dispatch the user-space scheduler every time that a CPU
* becomes available.
*/
dispatch_user_scheduler();
/*
* Consume a task from the per-CPU DSQ.
*/
if (scx_bpf_dsq_move_to_local(cpu_to_dsq(cpu)))
return;
/*
* Consume a task from the shared DSQ.
*/
if (scx_bpf_dsq_move_to_local(SHARED_DSQ))
return;
/*
* If the previous task was the user-space scheduler and it
* voluntarily released the CPU without dispatching any task, it
* means that there are no pending actions to be done, so let the
* CPU go idle.
*/
if (prev && is_usersched_task(prev))
return;
/*
* If the current task expired its time slice and no other task
* wants to run, simply replenish its time slice and let it run for
* another round on the same CPU.
*/
if (prev && is_queued(prev)) {
prev->scx.slice = SCX_SLICE_DFL;
/*
* Notify the user-space scheduler if there are any pending
* tasks to be completed, before resuming the previous
* task.
*
* Keep in mind that if we don't refill the previous task's
* time slice, this check will be performed in
* ops.update_idle().
*/
if (usersched_has_pending_tasks())
set_usersched_needed();
}
}
void BPF_STRUCT_OPS(rustland_runnable, struct task_struct *p, u64 enq_flags)
{
struct task_ctx *tctx;
if (is_usersched_task(p))
return;
tctx = try_lookup_task_ctx(p);
if (!tctx)
return;
tctx->exec_runtime = 0;
}
/*
* Task @p starts on its selected CPU (update CPU ownership map).
*/
void BPF_STRUCT_OPS(rustland_running, struct task_struct *p)
{
s32 cpu = scx_bpf_task_cpu(p);
struct task_ctx *tctx;
if (is_usersched_task(p)) {
usersched_last_run_at = scx_bpf_now();
return;
}
dbg_msg("start: pid=%d (%s) cpu=%ld", p->pid, p->comm, cpu);
/*
* Mark the CPU as busy by setting the pid as owner (ignoring the
* user-space scheduler).
*/
__sync_fetch_and_add(&nr_running, 1);
tctx = try_lookup_task_ctx(p);
if (!tctx)
return;
tctx->last_run_at = scx_bpf_now();
}
/*
* Task @p stops running on its associated CPU (update CPU ownership map).
*/
void BPF_STRUCT_OPS(rustland_stopping, struct task_struct *p, bool runnable)
{
s32 cpu = scx_bpf_task_cpu(p);
struct task_ctx *tctx;
if (is_usersched_task(p))
return;
dbg_msg("stop: pid=%d (%s) cpu=%ld", p->pid, p->comm, cpu);
__sync_fetch_and_sub(&nr_running, 1);
tctx = try_lookup_task_ctx(p);
if (!tctx)
return;
/*
* Update the partial execution time since last sleep.
*/
tctx->exec_runtime += scx_bpf_now() - tctx->last_run_at;
}
/*
* A CPU is about to change its idle state.
*/
void BPF_STRUCT_OPS(rustland_update_idle, s32 cpu, bool idle)
{
/*
* Don't do anything if we exit from and idle state, a CPU owner will
* be assigned in .running().
*/
if (!idle)
return;
/*
* A CPU is now available, notify the user-space scheduler that tasks
* can be dispatched.
*/
if (usersched_has_pending_tasks()) {
set_usersched_needed();
/*
* Wake up the idle CPU and trigger a resched, so that it can
* immediately accept dispatched tasks.
*/
scx_bpf_kick_cpu(cpu, 0);
return;
}
}
/*
* Task @p changes cpumask: update its local cpumask generation counter.
*/
void BPF_STRUCT_OPS(rustland_set_cpumask, struct task_struct *p,
const struct cpumask *cpumask)
{
struct task_ctx *tctx;
tctx = try_lookup_task_ctx(p);
if (!tctx)
return;
tctx->cpumask_cnt++;
}
/*
* A CPU is taken away from the scheduler, preempting the current task by
* another one running in a higher priority sched_class.
*/
void BPF_STRUCT_OPS(rustland_cpu_release, s32 cpu,
struct scx_cpu_release_args *args)
{
struct task_struct *p = args->task;
/*
* If the interrupted task is the user-space scheduler make sure to
* re-schedule it immediately.
*/
dbg_msg("cpu preemption: pid=%d (%s)", p->pid, p->comm);
if (is_usersched_task(p))
set_usersched_needed();
}
/*
* A new task @p is being created.
*
* Allocate and initialize all the internal structures for the task (this
* function is allowed to block, so it can be used to preallocate memory).
*/
s32 BPF_STRUCT_OPS(rustland_init_task, struct task_struct *p,
struct scx_init_task_args *args)
{
struct task_ctx *tctx;
struct bpf_cpumask *cpumask;
tctx = bpf_task_storage_get(&task_ctx_stor, p, 0,
BPF_LOCAL_STORAGE_GET_F_CREATE);
if (!tctx)
return -ENOMEM;
/*
* Create task's L2 cache cpumask.
*/
cpumask = bpf_cpumask_create();
if (!cpumask)
return -ENOMEM;
cpumask = bpf_kptr_xchg(&tctx->l2_cpumask, cpumask);
if (cpumask)
bpf_cpumask_release(cpumask);
/*
* Create task's L3 cache cpumask.
*/
cpumask = bpf_cpumask_create();
if (!cpumask)
return -ENOMEM;
cpumask = bpf_kptr_xchg(&tctx->l3_cpumask, cpumask);
if (cpumask)
bpf_cpumask_release(cpumask);
return 0;
}
/*
* Heartbeat scheduler timer callback.
*
* If the system is completely idle the sched-ext watchdog may incorrectly
* detect that as a stall and automatically disable the scheduler. So, use this
* timer to periodically wake-up the scheduler and avoid long inactivity.
*
* This can also help to prevent real "stalling" conditions in the scheduler.
*/
static int usersched_timer_fn(void *map, int *key, struct bpf_timer *timer)
{
struct task_struct *p;
int err = 0;
/*
* Trigger the user-space scheduler if it has been inactive for
* more than USERSCHED_TIMER_NS.
*/
if (time_delta(scx_bpf_now(), usersched_last_run_at) >= USERSCHED_TIMER_NS) {
bpf_rcu_read_lock();
p = bpf_task_from_pid(usersched_pid);
if (p) {
s32 cpu;
set_usersched_needed();
cpu = scx_bpf_pick_idle_cpu(p->cpus_ptr, 0);
if (cpu >= 0)
scx_bpf_kick_cpu(cpu, SCX_KICK_IDLE);
bpf_task_release(p);
}
bpf_rcu_read_unlock();
}
/* Re-arm the timer */
err = bpf_timer_start(timer, USERSCHED_TIMER_NS, 0);
if (err)
scx_bpf_error("Failed to arm stats timer");
return 0;
}
/*
* Initialize the heartbeat scheduler timer.
*/
static int usersched_timer_init(void)
{
struct bpf_timer *timer;
u32 key = 0;
int err;
timer = bpf_map_lookup_elem(&usersched_timer, &key);
if (!timer) {
scx_bpf_error("Failed to lookup scheduler timer");
return -ESRCH;
}
bpf_timer_init(timer, &usersched_timer, CLOCK_BOOTTIME);
bpf_timer_set_callback(timer, usersched_timer_fn);
err = bpf_timer_start(timer, USERSCHED_TIMER_NS, 0);
if (err)
scx_bpf_error("Failed to arm scheduler timer");
return err;
}
/*
* Evaluate the amount of online CPUs.
*/
static s32 get_nr_online_cpus(void)
{
const struct cpumask *online_cpumask;
u64 nr_cpu_ids = scx_bpf_nr_cpu_ids();
int i, cpus = 0;
online_cpumask = scx_bpf_get_online_cpumask();
bpf_for(i, 0, nr_cpu_ids) {
if (!bpf_cpumask_test_cpu(i, online_cpumask))
continue;
cpus++;
}
scx_bpf_put_cpumask(online_cpumask);
return cpus;
}
/*
* Create a DSQ for each CPU available in the system and a global shared DSQ.
*
* All the tasks processed by the user-space scheduler can be dispatched either
* to a specific CPU/DSQ or to the first CPU available (SHARED_DSQ).
*
* Custom DSQs are then consumed from the .dispatch() callback, that will
* transfer all the enqueued tasks to the consuming CPU's local DSQ.
*/
static int dsq_init(void)
{
u64 nr_cpu_ids = scx_bpf_nr_cpu_ids();
int err;
s32 cpu;
/* Initialize amount of online CPUs */
nr_online_cpus = get_nr_online_cpus();
/* Create per-CPU DSQs */
bpf_for(cpu, 0, nr_cpu_ids) {
err = scx_bpf_create_dsq(cpu_to_dsq(cpu), -1);
if (err) {
scx_bpf_error("failed to create pcpu DSQ %d: %d",
cpu, err);
return err;
}
}
/* Create the global shared DSQ */
err = scx_bpf_create_dsq(SHARED_DSQ, -1);
if (err) {
scx_bpf_error("failed to create shared DSQ: %d", err);
return err;
}
return 0;
}
static int init_cpumask(struct bpf_cpumask **cpumask)
{
struct bpf_cpumask *mask;
int err = 0;
/*
* Do nothing if the mask is already initialized.
*/
mask = *cpumask;
if (mask)
return 0;
/*
* Create the CPU mask.
*/
err = calloc_cpumask(cpumask);
if (!err)
mask = *cpumask;
if (!mask)
err = -ENOMEM;
return err;
}
SEC("syscall")
int enable_sibling_cpu(struct domain_arg *input)
{
struct cpu_ctx *cctx;
struct bpf_cpumask *mask, **pmask;
int err = 0;
cctx = try_lookup_cpu_ctx(input->cpu_id);
if (!cctx)
return -ENOENT;
/* Make sure the target CPU mask is initialized */
switch (input->lvl_id) {
case 2:
pmask = &cctx->l2_cpumask;
break;
case 3:
pmask = &cctx->l3_cpumask;
break;
default:
return -EINVAL;
}
err = init_cpumask(pmask);
if (err)
return err;
bpf_rcu_read_lock();
mask = *pmask;
if (mask)
bpf_cpumask_set_cpu(input->sibling_cpu_id, mask);
bpf_rcu_read_unlock();
return err;
}
/*
* Initialize the scheduling class.
*/
s32 BPF_STRUCT_OPS_SLEEPABLE(rustland_init)
{
int err;
/* Compile-time checks */
BUILD_BUG_ON((MAX_CPUS % 2));
/* Initialize rustland core */
err = dsq_init();
if (err)
return err;
err = usersched_timer_init();
if (err)
return err;
return 0;
}
/*
* Unregister the scheduling class.
*/
void BPF_STRUCT_OPS(rustland_exit, struct scx_exit_info *ei)
{
UEI_RECORD(uei, ei);
}
/*
* Scheduling class declaration.
*/
SCX_OPS_DEFINE(rustland,
.select_cpu = (void *)rustland_select_cpu,
.enqueue = (void *)rustland_enqueue,
.dispatch = (void *)rustland_dispatch,
.runnable = (void *)rustland_runnable,
.running = (void *)rustland_running,
.stopping = (void *)rustland_stopping,
.update_idle = (void *)rustland_update_idle,
.set_cpumask = (void *)rustland_set_cpumask,
.cpu_release = (void *)rustland_cpu_release,
.init_task = (void *)rustland_init_task,
.init = (void *)rustland_init,
.exit = (void *)rustland_exit,
.flags = SCX_OPS_KEEP_BUILTIN_IDLE | SCX_OPS_ENQ_LAST,
.timeout_ms = 5000,
.dispatch_max_batch = MAX_DISPATCH_SLOT,
.name = "rustland");
scx-1.0.12/rust/scx_rustland_core/bindings.h 0000664 0000000 0000000 00000000043 15007705772 0021063 0 ustar 00root root 0000000 0000000 #include "bpf_h/vmlinux/vmlinux.h"
scx-1.0.12/rust/scx_rustland_core/bpf_h 0000777 0000000 0000000 00000000000 15007705772 0023361 2../../scheds/include ustar 00root root 0000000 0000000 scx-1.0.12/rust/scx_rustland_core/build.rs 0000664 0000000 0000000 00000000360 15007705772 0020564 0 ustar 00root root 0000000 0000000 // Copyright (c) Meta Platforms, Inc. and affiliates.
//
// This software may be used and distributed according to the terms of the
// GNU General Public License version 2.
use scx_utils::Builder;
fn main() {
Builder::new().build()
}
scx-1.0.12/rust/scx_rustland_core/src/ 0000775 0000000 0000000 00000000000 15007705772 0017707 5 ustar 00root root 0000000 0000000 scx-1.0.12/rust/scx_rustland_core/src/alloc.rs 0000664 0000000 0000000 00000052274 15007705772 0021361 0 ustar 00root root 0000000 0000000 // Copyright (c) Andrea Righi
// Buddy allocator code imported from https://github.com/jjyr/buddy-alloc
// and distributed under the terms of the MIT license.
//
// MIT License:
//
// 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.
// This software may be used and distributed according to the terms of the
// GNU General Public License version 2.
use seccomp::*;
use std::alloc::{GlobalAlloc, Layout};
use std::fs::File;
use std::io::{BufRead, BufReader, Write};
use std::num::ParseIntError;
use std::sync::Mutex;
/// Buddy allocator
///
/// The following code is strongly based on and imported
/// directly here to make packaging easier.
const OOM_MSG: &str = "requires more memory space to initialize BuddyAlloc";
const LEAF_ALIGN_ERROR_MSG: &str = "leaf size must be align to 16 bytes";
/// required align to 16 bytes, since Node takes 16 bytes on 64-bits machine.
pub const MIN_LEAF_SIZE_ALIGN: usize = 16;
const fn block_size_2base(k: usize, leaf2base: usize) -> usize {
(1 << k) << leaf2base
}
const fn nblock(k: usize, entries_size: usize) -> usize {
1 << (entries_size - k - 1)
}
const fn roundup(n: usize, sz2base: usize) -> usize {
(((n - 1) >> sz2base) + 1) << sz2base
}
fn log2(mut n: usize) -> usize {
let mut k = 0;
while n > 1 {
k += 1;
n >>= 1;
}
k
}
fn bit_isset(bit_array: *const u8, i: usize) -> bool {
unsafe {
let b = bit_array.add(i >> 3);
let m = 1 << (i % 8);
*b & m == m
}
}
fn bit_set(bit_array: *mut u8, i: usize) {
unsafe {
let b = bit_array.add(i >> 3);
let m = 1 << (i % 8);
*b |= m;
}
}
fn bit_clear(bit_array: *mut u8, i: usize) {
debug_assert!(bit_isset(bit_array, i));
unsafe {
let b = bit_array.add(i >> 3);
let m = 1 << (i % 8);
*b &= !m;
}
}
// find a min k that great than n bytes
pub fn first_up_k(n: usize, leaf_size: usize) -> usize {
let mut k = 0;
let mut size = leaf_size;
while size < n {
k += 1;
size <<= 1;
}
k
}
struct Node {
next: *mut Node,
prev: *mut Node,
}
impl Node {
fn init(list: *mut Node) {
unsafe {
(*list).next = list;
(*list).prev = list;
}
}
fn remove(list: *mut Node) {
unsafe {
(*(*list).prev).next = (*list).next;
(*(*list).next).prev = (*list).prev;
}
}
fn pop(list: *mut Node) -> *mut Node {
debug_assert!(!Self::is_empty(list));
let n_list: *mut Node = unsafe { (*list).next };
Self::remove(n_list);
n_list
}
fn push(list: *mut Node, p: *mut u8) {
let p = p.cast::();
unsafe {
let n_list: Node = Node {
prev: list,
next: (*list).next,
};
// pointer aligned to 16 bytes(MIN_LEAF_SIZE_ALIGN), so it's safe to use write
p.write(n_list);
(*(*list).next).prev = p;
(*list).next = p;
}
}
fn is_empty(list: *const Node) -> bool {
unsafe { (*list).next as *const Node == list }
}
}
struct Entry {
free: *mut Node,
/// Bit array to keep tracking alloc
alloc: *mut u8,
/// Bit array to keep tracking split
split: *mut u8,
}
impl Default for Entry {
fn default() -> Self {
Entry {
free: core::ptr::null_mut(),
alloc: core::ptr::null_mut(),
split: core::ptr::null_mut(),
}
}
}
#[derive(Clone, Copy)]
pub struct BuddyAllocParam {
/// Base addr: the start address
base_addr: *const u8,
/// Len: available bytes from the start address
len: usize,
/// Leaf size: the min size to allocate
leaf_size: usize,
/// Zero filled: in many cases, provided address might already be zero filled,
/// in which case we can reduce re-filling zeros to the data again.
zero_filled: bool,
}
impl BuddyAllocParam {
/// Base addr: the start address
/// Len: available bytes from the start address
/// Leaf size: the min size to allocate
pub const fn new(base_addr: *const u8, len: usize, leaf_size: usize) -> Self {
BuddyAllocParam {
base_addr,
len,
leaf_size,
zero_filled: false,
}
}
}
pub struct BuddyAlloc {
/// memory start addr
base_addr: usize,
/// memory end addr
end_addr: usize,
/// unavailable memories at end_addr
unavailable: usize,
entries: *mut Entry,
entries_size: usize,
/// min size of a block, represent in 1 << leaf2base
leaf2base: usize,
}
impl BuddyAlloc {
/// # Safety
///
/// The `base_addr..(base_addr + len)` must be allocated before using,
/// and must guarantee no others write to the memory range, to avoid undefined behaviors.
/// The new function panic if memory space not enough for initialize BuddyAlloc.
pub unsafe fn new(param: BuddyAllocParam) -> Self {
unsafe {
let BuddyAllocParam {
base_addr,
len,
leaf_size,
zero_filled,
} = param;
let mut base_addr = base_addr as usize;
let end_addr = base_addr + len;
assert!(
leaf_size % MIN_LEAF_SIZE_ALIGN == 0 && leaf_size != 0,
"{}",
LEAF_ALIGN_ERROR_MSG
);
let leaf2base = log2(leaf_size);
base_addr = roundup(base_addr, leaf2base);
// we use (k + 1)-th entry's split flag to test existence of k-th entry's blocks;
// to accoding this convention, we make a dummy (entries_size - 1)-th entry.
// so we plus 2 on entries_size.
let entries_size = log2((end_addr - base_addr) >> leaf2base) + 2;
// alloc buddy allocator memory
let used_bytes = core::mem::size_of::() * entries_size;
debug_assert!(end_addr >= base_addr + used_bytes, "{}", OOM_MSG);
let entries = base_addr as *mut Entry;
base_addr += used_bytes;
let buddy_list_size = core::mem::size_of::();
// init entries free
for k in 0..entries_size {
// use one bit for per memory block
debug_assert!(end_addr >= base_addr + buddy_list_size, "{}", OOM_MSG);
let entry = entries.add(k).as_mut().expect("entry");
entry.free = base_addr as *mut Node;
if !zero_filled {
core::ptr::write_bytes(entry.free, 0, buddy_list_size);
}
Node::init(entry.free);
base_addr += buddy_list_size;
}
// init alloc
for k in 0..entries_size {
// use one bit for per memory block
// use shift instead `/`, 8 == 1 << 3
let used_bytes = roundup(nblock(k, entries_size), 3) >> 3;
debug_assert!(end_addr >= base_addr + used_bytes, "{}", OOM_MSG);
let entry = entries.add(k).as_mut().expect("entry");
entry.alloc = base_addr as *mut u8;
// mark all blocks as allocated
if !zero_filled {
core::ptr::write_bytes(entry.alloc, 0, used_bytes);
}
base_addr += used_bytes;
}
// init split
for k in 1..entries_size {
// use one bit for per memory block
// use shift instead `/`, 8 == 1 << 3
let used_bytes = roundup(nblock(k, entries_size), 3) >> 3;
debug_assert!(end_addr >= base_addr + used_bytes, "{}", OOM_MSG);
let entry = entries.add(k).as_mut().expect("entry");
entry.split = base_addr as *mut u8;
if !zero_filled {
core::ptr::write_bytes(entry.split, 0, used_bytes);
}
base_addr += used_bytes;
}
// align base_addr to leaf size
base_addr = roundup(base_addr, leaf2base);
assert!(end_addr >= base_addr, "{}", OOM_MSG);
debug_assert_eq!(
(base_addr >> leaf2base) << leaf2base,
base_addr,
"misalignment"
);
let mut allocator = BuddyAlloc {
base_addr,
end_addr,
entries,
entries_size,
leaf2base,
unavailable: 0,
};
allocator.init_free_list();
allocator
}
}
fn init_free_list(&mut self) {
let mut base_addr = self.base_addr;
let end_addr = self.end_addr;
let entries_size = self.entries_size;
// try alloc blocks
for k in (0..(entries_size - 1)).rev() {
let block_size = block_size_2base(k, self.leaf2base);
let entry = self.entry(k);
let parent_entry = self.entry(k + 1);
// alloc free blocks
while base_addr + block_size <= end_addr {
debug_assert!(!bit_isset(
entry.alloc,
self.block_index(k, base_addr as *const u8)
));
Node::push(entry.free, base_addr as *mut u8);
// mark parent's split and alloc
let block_index = self.block_index(k, base_addr as *const u8);
if block_index & 1 == 0 {
let parent_index = self.block_index(k + 1, base_addr as *const u8);
bit_set(parent_entry.alloc, parent_index);
bit_set(parent_entry.split, parent_index);
}
base_addr += block_size;
}
// mark unavailable blocks as allocated
let n = nblock(k, entries_size);
let unavailable_block_index = self.block_index(k, base_addr as *const u8);
debug_assert!(unavailable_block_index < n);
bit_set(entry.alloc, unavailable_block_index);
}
self.unavailable = end_addr - base_addr;
}
pub fn malloc(&mut self, nbytes: usize) -> *mut u8 {
let fk = first_up_k(nbytes, 1 << self.leaf2base);
let mut k = match (fk..self.entries_size).find(|&k| !Node::is_empty(self.entry(k).free)) {
Some(k) => k,
None => return core::ptr::null_mut(),
};
let p: *mut u8 = Node::pop(self.entry(k).free) as *mut u8;
bit_set(self.entry(k).alloc, self.block_index(k, p));
while k > fk {
let q: *mut u8 = (p as usize + block_size_2base(k - 1, self.leaf2base)) as *mut u8;
bit_set(self.entry(k).split, self.block_index(k, p));
let parent_entry = self.entry(k - 1);
bit_set(parent_entry.alloc, self.block_index(k - 1, p));
debug_assert!(!bit_isset(parent_entry.alloc, self.block_index(k - 1, q)));
Node::push(parent_entry.free, q);
k -= 1;
}
debug_assert_eq!(
((p as usize) >> self.leaf2base) << self.leaf2base,
p as usize,
"misalignment"
);
p
}
pub fn free(&mut self, mut p: *mut u8) {
let mut k = self.find_k_for_p(p);
while k < (self.entries_size - 1) {
let block_index = self.block_index(k, p);
let entry = self.entry(k);
bit_clear(entry.alloc, block_index);
let is_head = block_index & 1 == 0;
let buddy = if is_head {
block_index + 1
} else {
block_index - 1
};
if bit_isset(entry.alloc, buddy) {
break;
}
// merge buddy since its free
// 1. clear split of k + 1
// 2. set p to the address of merged block
// 3. repeat for k = k + 1 until reach MAX_K
// 4. push p back to k entry free list
let q = self.block_addr(k, buddy);
Node::remove(q as *mut Node);
if !is_head {
p = q as *mut u8;
}
bit_clear(self.entry(k + 1).split, self.block_index(k + 1, p));
k += 1;
}
debug_assert!(!bit_isset(self.entry(k).alloc, self.block_index(k, p)));
Node::push(self.entry(k).free, p);
}
fn entry(&self, i: usize) -> &Entry {
debug_assert!(i < self.entries_size, "index out of range");
unsafe { self.entries.add(i).as_ref().expect("entry") }
}
/// find k for p
fn find_k_for_p(&self, p: *const u8) -> usize {
for k in 0..(self.entries_size - 1) {
if bit_isset(self.entry(k + 1).split, self.block_index(k + 1, p)) {
debug_assert!(bit_isset(self.entry(k).alloc, self.block_index(k, p)));
return k;
}
}
0
}
/// block index of p under k
fn block_index(&self, k: usize, p: *const u8) -> usize {
if (p as usize) < self.base_addr {
// TODO handle this outside
panic!("out of memory");
}
let n = p as usize - self.base_addr;
// equal to: n / block_size_2base(k, self.leaf2base);
let index = (n >> k) >> self.leaf2base;
debug_assert!(index < nblock(k, self.entries_size));
index
}
/// block addr of index under k
fn block_addr(&self, k: usize, i: usize) -> usize {
// equal to: i * block_size_2base(k, self.leaf2base);
let n = (i << k) << self.leaf2base;
self.base_addr + n
}
}
// Main allocator class.
pub struct UserAllocator {
buddy_alloc_param: BuddyAllocParam,
inner_buddy_alloc: Mutex>,
}
impl UserAllocator {
pub const fn new(buddy_alloc_param: BuddyAllocParam) -> Self {
UserAllocator {
inner_buddy_alloc: Mutex::new(None),
buddy_alloc_param,
}
}
unsafe fn fetch_buddy_alloc R>(&self, f: F) -> R {
unsafe {
let mut inner = self.inner_buddy_alloc.lock().unwrap();
let alloc = inner.get_or_insert_with(|| BuddyAlloc::new(self.buddy_alloc_param));
f(alloc)
}
}
// Enable a seccomp filter that sends a SIGSYS when mmap() is called.
#[allow(static_mut_refs)]
pub fn disable_mmap(&self) -> Result<(), Box> {
let mut ctx = seccomp::Context::default(Action::Allow)?;
let syscall_nr = libc::SYS_mmap as usize;
let cmp = Compare::arg(0)
.using(Op::MaskedEq)
.with(0)
.build()
.ok_or("Failed to build seccomp filter")?;
let rule = Rule::new(syscall_nr, cmp, Action::Errno(libc::EPERM));
ctx.add_rule(rule)?;
ctx.load()?;
Ok(())
}
#[allow(static_mut_refs)]
pub fn lock_memory(&self) {
unsafe {
match VM.save() {
Ok(_) => {}
Err(res) => eprintln!("WARNING: {}\n", res),
};
// Call setrlimit to set the locked-in-memory limit to unlimited.
let new_rlimit = libc::rlimit {
rlim_cur: libc::RLIM_INFINITY,
rlim_max: libc::RLIM_INFINITY,
};
let res = libc::setrlimit(libc::RLIMIT_MEMLOCK, &new_rlimit);
if res != 0 {
panic!("setrlimit failed with error code: {}", res);
}
// Lock all memory to prevent being paged out.
let res = libc::mlockall(libc::MCL_CURRENT | libc::MCL_FUTURE);
if res != 0 {
panic!("mlockall failed with error code: {}", res);
}
};
}
#[allow(static_mut_refs)]
pub fn unlock_memory(&self) {
unsafe {
match VM.restore() {
Ok(_) => {}
Err(res) => eprintln!("WARNING: {}\n", res),
}
};
}
}
// Override global allocator methods.
unsafe impl GlobalAlloc for UserAllocator {
unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
unsafe {
let bytes = layout.size();
self.fetch_buddy_alloc(|alloc| alloc.malloc(bytes))
}
}
unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) {
unsafe {
self.fetch_buddy_alloc(|alloc| alloc.free(ptr));
}
}
}
unsafe impl Sync for UserAllocator {}
// Buddy allocator parameters.
const HEAP_SIZE: usize = 64 * 1024 * 1024; // 64M
const LEAF_SIZE: usize = 64;
#[repr(align(4096))]
struct AlignedHeap([u8; N]);
// Statically pre-allocated memory arena.
static mut HEAP: AlignedHeap = AlignedHeap([0u8; HEAP_SIZE]);
// Override default memory allocator.
//
// To prevent potential deadlock conditions under heavy loads, any scheduler that delegates
// scheduling decisions to user-space should avoid triggering page faults.
//
// To address this issue, replace the global allocator with a custom one (UserAllocator),
// designed to operate on a pre-allocated buffer. This, coupled with the memory locking achieved
// through mlockall(), prevents page faults from occurring during the execution of the user-space
// scheduler.
#[allow(static_mut_refs)]
#[cfg_attr(not(test), global_allocator)]
pub static ALLOCATOR: UserAllocator =
unsafe { UserAllocator::new(BuddyAllocParam::new(HEAP.0.as_ptr(), HEAP_SIZE, LEAF_SIZE)) };
// State of special sysctl VM settings.
//
// This is used to save the previous state of some procfs settings that must be changed by the
// user-space scheduler.
struct VmSettings {
// We cannot allow page faults in the user-space scheduler, otherwise we may hit deadlock
// conditions: a kthread may need to run to resolve the page fault, but the user-space
// scheduler is waiting on the page fault to be resolved => deadlock.
//
// To prevent this from happening automatically enforce vm.compact_unevictable_allowed=0 when
// the scheduler is running, to disable compaction of unevictable memory pages and make sure
// that the scheduler never faults.
//
// The original value will be restored when the user-space scheduler exits.
compact_unevictable_allowed: i32,
}
impl VmSettings {
// Return the content of a procfs file as i32.
fn read_procfs(&self, file_path: &str) -> Result {
// Attempt to open the file
let file = match File::open(file_path) {
Ok(f) => f,
Err(err) => return Err(format!("Failed to open {}: {}", file_path, err)),
};
let reader = BufReader::new(file);
if let Some(Ok(line)) = reader.lines().next() {
let value: Result = line.trim().parse();
match value {
Ok(v) => Ok(v),
Err(err) => Err(format!("Failed to parse {}: {}", file_path, err)),
}
} else {
Err(format!("File is empty: {}", file_path))
}
}
// Write an i32 to a file in procfs.
fn write_procfs(&self, file_path: &str, value: i32) -> Result<(), String> {
// Attempt to create or open the file
let mut file = match File::create(file_path) {
Ok(f) => f,
Err(err) => return Err(format!("Failed to open {}: {}", file_path, err)),
};
// Attempt to write the value to the file
if let Err(err) = write!(file, "{}", value) {
return Err(format!("Failed to write to {}: {}", file_path, err));
}
Ok(()) // Return Ok if writing was successful
}
// Save all the sysctl VM settings in the internal state.
fn save(&self) -> Result<(), String> {
let compact_unevictable_allowed = "/proc/sys/vm/compact_unevictable_allowed";
let value = self.read_procfs(compact_unevictable_allowed)?;
unsafe {
VM.compact_unevictable_allowed = value;
};
self.write_procfs(compact_unevictable_allowed, 0)?;
Ok(())
}
// Restore all the previous sysctl vm settings.
fn restore(&self) -> Result<(), String> {
let compact_unevictable_allowed = "/proc/sys/vm/compact_unevictable_allowed";
let value = unsafe { VM.compact_unevictable_allowed };
self.write_procfs(compact_unevictable_allowed, value)?;
Ok(())
}
}
// Special sysctl VM settings.
static mut VM: VmSettings = VmSettings {
compact_unevictable_allowed: 0,
};
scx-1.0.12/rust/scx_rustland_core/src/bindings.rs 0000664 0000000 0000000 00000000246 15007705772 0022054 0 ustar 00root root 0000000 0000000 #![allow(non_upper_case_globals)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(dead_code)]
include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
scx-1.0.12/rust/scx_rustland_core/src/bpf_intf.rs 0000664 0000000 0000000 00000000433 15007705772 0022044 0 ustar 00root root 0000000 0000000 // This software may be used and distributed according to the terms of the
// GNU General Public License version 2.
#![allow(non_upper_case_globals)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(dead_code)]
include!(concat!(env!("OUT_DIR"), "/bpf_intf.rs"));
scx-1.0.12/rust/scx_rustland_core/src/bpf_skel.rs 0000664 0000000 0000000 00000000251 15007705772 0022040 0 ustar 00root root 0000000 0000000 // This software may be used and distributed according to the terms of the
// GNU General Public License version 2.
include!(concat!(env!("OUT_DIR"), "/bpf_skel.rs"));
scx-1.0.12/rust/scx_rustland_core/src/lib.rs 0000664 0000000 0000000 00000000264 15007705772 0021025 0 ustar 00root root 0000000 0000000 mod bindings;
pub const VERSION: &'static str = env!("CARGO_PKG_VERSION");
mod alloc;
pub use alloc::ALLOCATOR;
mod rustland_builder;
pub use rustland_builder::RustLandBuilder;
scx-1.0.12/rust/scx_rustland_core/src/rustland_builder.rs 0000664 0000000 0000000 00000003407 15007705772 0023623 0 ustar 00root root 0000000 0000000 // Copyright (c) Andrea Righi
// This software may be used and distributed according to the terms of the
// GNU General Public License version 2.
use anyhow::Result;
use scx_utils::BpfBuilder;
use std::fs;
use std::fs::File;
use std::io::Write;
use std::path::Path;
pub struct RustLandBuilder {
inner_builder: BpfBuilder,
}
impl RustLandBuilder {
pub fn new() -> Result {
Ok(Self {
inner_builder: BpfBuilder::new()?,
})
}
fn create_file(&self, file_name: &str, content: &[u8]) {
let path = Path::new(file_name);
// Limit file writing to when file contents differ (for caching)
if let Ok(bytes_there) = fs::read(path) {
if bytes_there == content {
return;
}
}
let mut file = File::create(path).expect("Unable to create file");
file.write_all(content).expect("Unable to write to file");
}
pub fn build(&mut self) -> Result<()> {
// Embed the BPF source files.
let intf = include_bytes!(concat!(env!("CARGO_MANIFEST_DIR"), "/assets/bpf/intf.h"));
let skel = include_bytes!(concat!(
env!("CARGO_MANIFEST_DIR"),
"/assets/bpf/main.bpf.c"
));
let bpf = include_bytes!(concat!(env!("CARGO_MANIFEST_DIR"), "/assets/bpf.rs"));
// Generate BPF backend code (C).
self.create_file("intf.h", intf);
self.create_file("main.bpf.c", skel);
self.inner_builder.enable_intf("intf.h", "bpf_intf.rs");
self.inner_builder.enable_skel("main.bpf.c", "bpf");
// Generate user-space BPF connector code (Rust).
self.create_file("src/bpf.rs", bpf);
// Build the scheduler.
self.inner_builder.build()
}
}
scx-1.0.12/rust/scx_stats/ 0000775 0000000 0000000 00000000000 15007705772 0015412 5 ustar 00root root 0000000 0000000 scx-1.0.12/rust/scx_stats/Cargo.toml 0000664 0000000 0000000 00000001213 15007705772 0017337 0 ustar 00root root 0000000 0000000 [package]
name = "scx_stats"
version = "1.0.12"
edition = "2021"
authors = ["Tejun Heo "]
license = "GPL-2.0-only"
repository = "https://github.com/sched-ext/scx"
description = "Statistics transport library for sched_ext schedulers"
[dependencies]
anyhow = "1.0.65"
crossbeam = "0.8.4"
libc = "0.2.137"
log = "0.4.17"
proc-macro2 = "1.0"
quote = "1.0"
serde = { version = "1.0.215", features = ["derive"] }
serde_json = "1.0.133"
syn = { version = "2.0", features = ["extra-traits", "full"] }
[dev-dependencies]
scx_stats_derive = { path = "scx_stats_derive" }
simple_logger = "5.0"
[lints.clippy]
not_unsafe_ptr_arg_deref = "allow"
scx-1.0.12/rust/scx_stats/LICENSE 0000777 0000000 0000000 00000000000 15007705772 0020045 2../../LICENSE ustar 00root root 0000000 0000000 scx-1.0.12/rust/scx_stats/README.md 0000664 0000000 0000000 00000020077 15007705772 0016677 0 ustar 00root root 0000000 0000000 # Statistics transport library for sched_ext schedulers
[sched_ext](https://github.com/sched-ext/scx) is a Linux kernel feature
which enables implementing kernel thread schedulers in BPF and dynamically
loading them.
This library provides an easy way to define statistics and access them
through a UNIX domain socket. While this library is developed for SCX
schedulers, it can be used elsewhere as the only baked-in assumption is the
default UNIX domain socket path which can be overridden.
Statistics are defined as structs. A statistics struct can contain the
following fields:
- Numbers - i32, u32, i64, u64, f64.
- Strings.
- Structs containing allowed fields.
- `Vec`s and `BTreeMap`s containing the above.
The following is taken from [`examples/stats_defs.rs.h`](./examples/stats_defs.rs.h):
```rust
#[derive(Clone, Debug, Serialize, Deserialize, Stats)]
#[stat(desc = "domain statistics", _om_prefix="d_", _om_label="domain_name")]
struct DomainStats {
pub name: String,
#[stat(desc = "an event counter")]
pub events: u64,
#[stat(desc = "a gauge number")]
pub pressure: f64,
}
#[derive(Clone, Debug, Serialize, Deserialize, Stats)]
#[stat(desc = "cluster statistics", top)]
struct ClusterStats {
pub name: String,
#[stat(desc = "update timestamp")]
pub at: u64,
#[stat(desc = "some bitmap we want to report", _om_skip)]
pub bitmap: Vec,
#[stat(desc = "domain statistics")]
pub doms_dict: BTreeMap,
}
```
`scx_stats_derive::Stats` is the derive macro which generates everything
necessary including the statistics metadata. The `stat` struct and field
attribute allows adding annotations. The following attributes are currently
defined:
*struct and field attributes*
- desc: Description.
*struct-only attributes*
- top: Marks the top-level statistics struct which is reported by default.
Used by generic tools to find the starting point when processing the
metadata.
In addition, arbitrary user attributes which start with "_" can be added to
both structs and fields. They are collected into the "user" dict of the
containing struct or field. When the value of such user attribute is not
specified, the string "true" is assigned by default. For example,
[scripts/scxstats_to_openmetrics.py](scripts/scxstats_to_openmetrics.py)
recognizes the following user attribute:
- `_om_prefix`: The value is prefixed to the field name to form the unique
OpenMetrics metric name.
- `_om_label`: Labels are used to distinguish different members of a dict.
This field attribute specifies the name of the label for a dict field.
- `_om_skip`: Not all fields might make sense to translate to OpenMetrics.
This valueless field attribute marks the field to be skipped.
[`examples/stats_defs.rs.h`](./examples/stats_defs.rs.h) shows how the above
attributes can be used. See
[scx_layered](https://github.com/sched-ext/scx/tree/main/scheds/rust/scx_layered/src/stats.rs)
for practical usage.
Note that scx_stats depends on [`serde`](https://crates.io/crates/serde) and
[`serde_json`](https://crates.io/crates/serde_json) and each statistics
struct must derive `Serialize` and `Deserialize`.
The statistics server which serves the above structs through a UNIX domain
socket can be launched as follows:
```rust
let _server = ScxStatsServer::new()
.set_path(&path)
.add_stats_meta(ClusterStats::meta())
.add_stats_meta(DomainStats::meta())
.add_stats("top", Box::new(move |_| stats.to_json()))
.launch()
.unwrap();
```
The `scx_stats::Meta::meta()` trait function is automatically implemented by
the `scx_stats::Meta` derive macro for each statistics struct. Adding them
to the statistics server allows implementing generic clients which don't
have the definitions of the statistics structs - e.g. to relay the
statistics to another framework such as OpenMetrics.
`top` is the default statistics reported when no specific target is
specified and should always be added to the server. The closure should
return `serde_json::Value`. Note that `scx_stats::ToJson` automatically adds
`.to_json()` to structs which implement both `scx_stats::Meta` and
`serde::Serialize`.
The above will launch the statistics server listening on `@path`. Note that
the server will shutdown when `_server` variable is dropped. The client side
is also simple. Taken from [`examples/client.rs`](./examples/client.rs):
```rust
let mut client = ScxStatsClient::new().set_path(path).connect().unwrap();
```
The above creates a client instance. Let's query the statistics:
```rust
let resp = client.request::("stat", vec![]);
println!("{:#?}", &resp);
```
The above is equivalent to querying the `top` target:
```rust
println!("\n===== Requesting \"stat\" with \"target\"=\"top\":");
let resp = client.request::("stat", vec![("target".into(), "top".into())]);
println!("{:#?}", &resp);
```
If `("args", BTreeMap)` is passed in as a part of the
`@args` vector, the `BTreeMap` will be passed as an argument to the handling
closure on the server side.
When implementing a generic client which does not have access to the
statistics struct definitions, the metadata can come handy:
```rust
println!("\n===== Requesting \"stats_meta\" but receiving with serde_json::Value:");
let resp = client.request::("stats_meta", vec![]).unwrap();
println!("{}", serde_json::to_string_pretty(&resp).unwrap());
```
For this example, the output would look like the following:
```
{
"ClusterStats": {
"desc": "cluster statistics",
"fields": {
"at": {
"datum": "u64",
"desc": "update timestamp"
},
"bitmap": {
"array": "u64",
"desc": "some bitmap we want to report",
"user": {
"_om_skip": "true"
}
},
"doms_dict": {
"desc": "domain statistics",
"dict": {
"datum": {
"struct": "DomainStats"
},
"key": "u64"
}
},
"name": {
"datum": "string"
}
},
"name": "ClusterStats",
"top": "true"
},
"DomainStats": {
"desc": "domain statistics",
"fields": {
"events": {
"datum": "u64",
"desc": "an event counter"
},
"name": {
"datum": "string"
},
"pressure": {
"datum": "float",
"desc": "a gauge number"
}
},
"name": "DomainStats",
"user": {
"_om_label": "domain_name",
"_om_prefix": "d_"
}
}
}
```
The protocol used for communication on the UNIX domain socket is line based
with each line containing a json and straightforward. Run `examples/client`
with `RUST_LOG=trace` set to see what get sent on the wire:
```
> cargo run --example server -- ~/tmp/socket
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.02s
Running `target/debug/examples/server /home/htejun/tmp/socket`
Server listening. Run `client "/home/htejun/tmp/socket"`.
Use `socat - UNIX-CONNECT:"/home/htejun/tmp/socket"` for raw connection.
Press any key to exit.
```
```
$ RUST_LOG=trace cargo run --example client -- ~/tmp/socket
...
===== Requesting "stats" but receiving with serde_json::Value:
2024-08-15T22:13:23.769Z TRACE [scx_stats::client] Sending: {"req":"stats","args":{"target":"top"}}
2024-08-15T22:13:23.769Z TRACE [scx_stats::client] Received: {"errno":0,"args":{"resp":{"at":12345,"bitmap":[3735928559,3203391149],"doms_dict":{"0":{"events":1234,"name":"domain 0","pressure":1.234},"3":{"events":5678,"name":"domain 3","pressure":5.678}},"name":"test cluster"}}}
Ok(
Object {
"at": Number(12345),
"bitmap": Array [
Number(3735928559),
Number(3203391149),
],
"doms_dict": Object {
"0": Object {
"events": Number(1234),
"name": String("domain 0"),
"pressure": Number(1.234),
},
"3": Object {
"events": Number(5678),
"name": String("domain 3"),
"pressure": Number(5.678),
},
},
"name": String("test cluster"),
},
```
scx-1.0.12/rust/scx_stats/examples/ 0000775 0000000 0000000 00000000000 15007705772 0017230 5 ustar 00root root 0000000 0000000 scx-1.0.12/rust/scx_stats/examples/client.rs 0000664 0000000 0000000 00000003361 15007705772 0021057 0 ustar 00root root 0000000 0000000 use scx_stats::prelude::*;
use scx_stats_derive::Stats;
use serde::{Deserialize, Serialize};
use std::collections::BTreeMap;
use std::env::args;
// Hacky definition sharing. See stats_def.rs.h.
include!("stats_defs.rs.h");
fn main() {
simple_logger::SimpleLogger::new()
.with_level(log::LevelFilter::Info)
.env()
.init()
.unwrap();
std::assert_eq!(args().len(), 2, "Usage: client UNIX_SOCKET_PATH");
let path = args().nth(1).unwrap();
let mut client = StatsClient::new().set_path(path).connect().unwrap();
println!("===== Requesting \"stats_meta\":");
let resp = client.request::>("stats_meta", vec![]);
println!("{:#?}", &resp);
println!("\n===== Requesting \"stats\" without arguments:");
let resp = client.request::("stats", vec![]);
println!("{:#?}", &resp);
println!("\n===== Requesting \"stats\" with \"target\"=\"non-existent\":");
let resp =
client.request::("stats", vec![("target".into(), "non-existent".into())]);
println!("{:#?}", &resp);
println!("\n===== Requesting \"stats\" with \"target\"=\"all\":");
let resp = client.request::("stats", vec![("target".into(), "top".into())]);
println!("{:#?}", &resp);
println!("\n===== Requesting \"stats\" but receiving with serde_json::Value:");
let resp = client.request::("stats", vec![("target".into(), "top".into())]);
println!("{:#?}", &resp);
println!("\n===== Requesting \"stats_meta\" but receiving with serde_json::Value:");
let resp = client
.request::("stats_meta", vec![])
.unwrap();
println!("{}", serde_json::to_string_pretty(&resp).unwrap());
}
scx-1.0.12/rust/scx_stats/examples/server.rs 0000664 0000000 0000000 00000005216 15007705772 0021110 0 ustar 00root root 0000000 0000000 use log::{debug, info, warn};
use scx_stats::prelude::*;
use scx_stats_derive::Stats;
use serde::{Deserialize, Serialize};
use std::collections::BTreeMap;
use std::env::args;
use std::io::Read;
use std::thread::{current, spawn, ThreadId};
// Hacky definition sharing. See stats_def.rs.h.
include!("stats_defs.rs.h");
fn main() {
simple_logger::SimpleLogger::new()
.with_level(log::LevelFilter::Info)
.env()
.init()
.unwrap();
let stats = ClusterStats {
name: "test cluster".into(),
at: 12345,
bitmap: vec![0xdeadbeef, 0xbeefdead],
doms_dict: BTreeMap::from([
(
0,
DomainStats {
name: "domain 0".into(),
events: 1234,
pressure: 1.234,
},
),
(
3,
DomainStats {
name: "domain 3".into(),
events: 5678,
pressure: 5.678,
},
),
]),
};
std::assert_eq!(args().len(), 2, "Usage: server UNIX_SOCKET_PATH");
let path = args().nth(1).unwrap();
// If communication from the stats generating closure is not necessary,
// StatsServer::<(), ()> can be used. This example sends thread ID and
// receives the formatted string just for demonstration.
let sdata = StatsServerData::::new()
.add_meta(ClusterStats::meta())
.add_meta(DomainStats::meta())
.add_stats(
"top",
Box::new(move |_args, (tx, rx)| {
let id = current().id();
let res = tx.send(id);
debug!("Sendt {:?} {:?}", id, &res);
let res = rx.recv();
debug!("Recevied {:?}", res);
stats.to_json()
}),
);
info!("stats_meta:");
sdata.describe_meta(&mut std::io::stderr(), None).unwrap();
let server = StatsServer::::new(sdata)
.set_path(&path)
.launch()
.unwrap();
debug!("Doing unnecessary server channel handling");
let (tx, rx) = server.channels();
spawn(move || {
while let Ok(id) = rx.recv() {
if let Err(e) = tx.send(format!("hello {:?}", &id)) {
warn!("Server channel errored ({:?})", &e);
break;
}
}
});
info!("Server listening. Run `client {:?}`.", &path);
info!("Use `socat - UNIX-CONNECT:{:?}` for raw connection.", &path);
info!("Press any key to exit.");
let mut buf: [u8; 1] = [0];
let _ = std::io::stdin().read(&mut buf);
}
scx-1.0.12/rust/scx_stats/examples/stats_defs.rs.h 0000664 0000000 0000000 00000001601 15007705772 0022161 0 ustar 00root root 0000000 0000000 // To be included from server.rs and client.rs examples. This would usually
// be done through the usual pub struct definitions but it's cumbersome to
// do in the examples directory, so work around with c-like includes.
#[derive(Clone, Debug, Serialize, Deserialize, Stats)]
#[stat(desc = "domain statistics", _om_prefix="d_", _om_label="domain_name")]
struct DomainStats {
pub name: String,
#[stat(desc = "an event counter")]
pub events: u64,
#[stat(desc = "a gauge number")]
pub pressure: f64,
}
#[derive(Clone, Debug, Serialize, Deserialize, Stats)]
#[stat(desc = "cluster statistics", top)]
struct ClusterStats {
pub name: String,
#[stat(desc = "update timestamp")]
pub at: u64,
#[stat(desc = "some bitmap we want to report", _om_skip)]
pub bitmap: Vec,
#[stat(desc = "domain statistics")]
pub doms_dict: BTreeMap,
}
scx-1.0.12/rust/scx_stats/scripts/ 0000775 0000000 0000000 00000000000 15007705772 0017101 5 ustar 00root root 0000000 0000000 scx-1.0.12/rust/scx_stats/scripts/scxstats_to_openmetrics.py 0000775 0000000 0000000 00000014130 15007705772 0024443 0 ustar 00root root 0000000 0000000 #!/usr/bin/python3
import argparse
import sys
import json
import socket
import time
import tempfile
from prometheus_client import Gauge, CollectorRegistry, write_to_textfile
from pprint import pprint
verbose = 0
def info(line):
print('[INFO] ' + line, file=sys.stderr)
def dbg(line):
if verbose:
print('[DBG] ' + line, file=sys.stderr)
def request(f, req, args={}):
f.write(json.dumps({ 'req': req, 'args': args }) + '\n')
f.flush()
resp = json.loads(f.readline())
if resp['errno'] != 0:
raise Exception(f"req: {req} args: {args} failed with {resp['errno']} ({resp['args']['resp']})")
return resp['args']['resp']
def make_om_metrics(sname, omid, field, labels, meta_db, registry):
# @sname: The name of the current struct.
#
# @omid: The field path down from the top level struct. e.g. '.A.B'
# means that the top level's field 'A' is a dict and the current one is
# the field 'B' of the struct inside that dict.
#
# @field: The corresponding field part of the stats_meta.
#
# @labels: The collected $om_labels as this function descends down
# nested dicts.
# om_skip tells us that the server wants this field to be
# skipped for OM.
if 'user' in field and '_om_skip' in field['user']:
dbg(f'skipping {omid} due to _om_skip')
return {}
desc = field['desc'] if 'desc' in field else ''
prefix = meta_db[sname]['_om_prefix']
if 'datum' in field:
match field['datum']:
# Single value that can become a Gauge. Gauge name is
# $_om_prefix + the leaf level field name. The combination must
# be unique.
case 'i64' | 'u64' | 'float':
gname = prefix + omid.rsplit('.', 1)[-1]
dbg(f'creating OM metric {gname}@{omid} {labels} "{desc}"')
return { omid: Gauge(gname, desc, labels, registry=registry) }
elif 'dict' in field and 'datum' in field['dict'] and 'struct' in field['dict']['datum']:
# The only allowed nesting is struct inside dict.
sname = field['dict']['datum']['struct']
struct = meta_db[sname]
# $_om_label's will distinguish different members of the dict by
# pointing to the dict keys.
if not struct['_om_label']:
raise Exception(f'{omid} is nested inside but does not have _om_label')
# Recurse into the nested struct.
oms = {}
for fname, field in struct['fields'].items():
oms |= make_om_metrics(sname, f'{omid}.{fname}', field,
labels + [struct['_om_label']], meta_db, registry)
return oms
info(f'field "{omid}" has unsupported type, skipping')
return {}
def update_om_metrics(resp, omid, labels, meta_db, om_metrics):
for k, v in resp.items():
k_omid = f'{omid}.{k}'
if type(v) == dict:
# Descend into dict.
for dk, dv in v.items():
update_om_metrics(dv, k_omid, labels + [dk], meta_db, om_metrics);
elif k_omid in om_metrics:
# Update known metrics.
dbg(f'updating {k_omid} {labels} to {v}')
if len(labels):
om_metrics[k_omid].labels(*labels).set(v)
else:
om_metrics[k_omid].set(v)
else:
dbg(f'skpping {k_omid}')
def connect_and_monitor(args):
# Connect to the stats server.
sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
sock.connect(args.path)
f = sock.makefile(mode='rw')
# Query metadata and build meta_db.
meta_db = {}
resp = request(f, 'stats_meta')
top_sname = None
for sname, struct in resp.items():
# Find the top-level struct.
if 'top' in struct:
top_sname = sname
struct['_om_prefix'] = ''
struct['_om_label'] = ''
if 'user' in struct:
# _om_prefix is used to build unique metric name from field names.
if '_om_prefix' in struct['user']:
struct['_om_prefix'] = struct['user']['_om_prefix']
# _om_label is used to distinguish structs nested inside dicts.
if '_om_label' in struct['user']:
struct['_om_label'] = struct['user']['_om_label']
del struct['user']
meta_db[sname] = struct
if verbose:
dbg('dumping meta_db:')
pprint(meta_db)
if top_sname not in meta_db:
raise Exception(f'top-level statistics struct not found among {meta_db.keys()}')
# Instantiate OpenMetrics Gauges.
registry = CollectorRegistry()
om_metrics = {}
for name, field in meta_db[top_sname]['fields'].items():
om_metrics |= make_om_metrics(top_sname, f'.{name}', field, [], meta_db, registry)
# Loop and translate stats.
while True:
resp = request(f, 'stats')
if verbose:
dbg('dumping stats response:')
pprint(resp)
update_om_metrics(resp, '', [], meta_db, om_metrics)
with tempfile.NamedTemporaryFile() as out_file:
write_to_textfile(out_file.name, registry)
with open(out_file.name) as in_file:
sys.stdout.write(in_file.read())
sys.stdout.flush()
time.sleep(args.intv)
def main():
global verbose
parser = argparse.ArgumentParser(
prog='scxstats_to_openmetrics',
description='Read from scx_stats server and output in OpenMetrics format')
parser.add_argument('-i', '--intv', metavar='SECS', type=float, default='2.0',
help='Polling interval (default: %(default)s)')
parser.add_argument('-v', '--verbose', action='count')
parser.add_argument('-p', '--path', metavar='PATH', default='/var/run/scx/root/stats',
help='UNIX domain socket path to connect to (default: %(default)s)')
args = parser.parse_args()
verbose = args.verbose
last_e = None
while True:
try:
connect_and_monitor(args)
except Exception as e:
if verbose or f'{e}' != f'{last_e}':
info(f'{e}, retrying...')
last_e = e
time.sleep(1)
main()
scx-1.0.12/rust/scx_stats/scx_stats_derive/ 0000775 0000000 0000000 00000000000 15007705772 0020763 5 ustar 00root root 0000000 0000000 scx-1.0.12/rust/scx_stats/scx_stats_derive/Cargo.toml 0000664 0000000 0000000 00000000750 15007705772 0022715 0 ustar 00root root 0000000 0000000 [package]
name = "scx_stats_derive"
version = "1.0.12"
edition = "2021"
authors = ["Tejun Heo "]
license = "GPL-2.0-only"
repository = "https://github.com/sched-ext/scx"
description = "Derive macro for scx_stats"
[lib]
proc-macro = true
[dependencies]
proc-macro2 = "1.0"
quote = "1.0"
scx_stats = { path = "..", version = "1.0.12" }
serde_json = "1.0.133"
syn = { version = "2.0", features = ["extra-traits", "full"] }
[lints.clippy]
not_unsafe_ptr_arg_deref = "allow"
scx-1.0.12/rust/scx_stats/scx_stats_derive/LICENSE 0000777 0000000 0000000 00000000000 15007705772 0023631 2../../../LICENSE ustar 00root root 0000000 0000000 scx-1.0.12/rust/scx_stats/scx_stats_derive/README.md 0000664 0000000 0000000 00000000107 15007705772 0022240 0 ustar 00root root 0000000 0000000 # Derive macro crate for `scx_stats`
See [`scx_stats`](../README.md).
scx-1.0.12/rust/scx_stats/scx_stats_derive/src/ 0000775 0000000 0000000 00000000000 15007705772 0021552 5 ustar 00root root 0000000 0000000 scx-1.0.12/rust/scx_stats/scx_stats_derive/src/lib.rs 0000664 0000000 0000000 00000011754 15007705772 0022676 0 ustar 00root root 0000000 0000000 use quote::{format_ident, quote, quote_spanned};
use scx_stats::{StatsData, StatsKind, StatsMetaAux};
use std::sync::atomic::{AtomicU64, Ordering};
use syn::parse_macro_input;
use syn::spanned::Spanned;
use syn::{Attribute, Data, DeriveInput, Fields, Lit};
static ASSERT_IDX: AtomicU64 = AtomicU64::new(0);
#[proc_macro_derive(Stats, attributes(stat))]
pub fn stat(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
let stats_aux = parse_macro_input!(input as StatsMetaAux);
let (meta, ident, paths) = (stats_aux.meta, stats_aux.ident, stats_aux.paths);
let mut output = proc_macro2::TokenStream::new();
for (_fname, field) in meta.fields.iter() {
match &field.data {
StatsData::Datum(datum)
| StatsData::Array(datum)
| StatsData::Dict { key: _, datum } => {
if let StatsKind::Struct(name) = &datum {
let path = &paths[name.as_str()];
let idx = ASSERT_IDX.fetch_add(1, Ordering::Relaxed);
let assert_id = format_ident!("_AssertStatsMeta_{}", idx);
#[rustfmt::skip]
let assert = quote_spanned! {path.span()=>
struct #assert_id where #path: scx_stats::Meta;
};
output.extend(assert.into_iter());
}
}
}
}
let body = serde_json::to_string(&meta).unwrap();
let trait_body = quote! {
#[rustfmt::skip]
impl scx_stats::Meta for #ident {
fn meta() -> scx_stats::StatsMeta {
let body = #body;
scx_stats::serde_json::from_str(body).unwrap()
}
}
};
output.extend(trait_body);
output.into()
}
#[proc_macro_attribute]
pub fn stat_doc(
_attr: proc_macro::TokenStream,
item: proc_macro::TokenStream,
) -> proc_macro::TokenStream {
let input = parse_macro_input!(item as DeriveInput);
let ident = input.ident;
let vis = input.vis;
let attrs = input.attrs;
let generics = input.generics;
let data = input.data;
let mut output = proc_macro2::TokenStream::new();
if let Data::Struct(data_struct) = data {
let fields = match data_struct.fields {
Fields::Named(fields_named) => fields_named.named,
_ => {
return syn::Error::new_spanned(
ident,
"stat attribute can only be used on structs with named fields",
)
.to_compile_error()
.into();
}
};
let mut new_fields = Vec::new();
for mut field in fields {
let mut doc_string = None;
let mut new_attrs = Vec::new();
for attr in field.attrs.clone() {
if attr.path().is_ident("stat") {
// Parse the arguments within #[stat(...)]
attr.parse_nested_meta(|meta| {
if meta.path.is_ident("desc") {
// Extract the literal string value from `desc`
let desc_literal: Lit = meta.value()?.parse()?;
if let Lit::Str(lit_str) = desc_literal {
doc_string = Some(lit_str.value());
}
}
Ok(())
})
.unwrap_or_else(|err| {
panic!("Failed to parse the stat attribute: {}", err);
});
}
new_attrs.push(attr);
}
// If a description string was found, add a #[doc = "..."] attribute
if let Some(description) = doc_string {
let doc_attr = Attribute {
pound_token: syn::token::Pound::default(),
style: syn::AttrStyle::Outer,
bracket_token: syn::token::Bracket::default(),
meta: syn::Meta::NameValue(syn::MetaNameValue {
path: syn::Path::from(format_ident!("doc")),
eq_token: syn::token::Eq::default(),
value: syn::Expr::Lit(syn::ExprLit {
lit: Lit::Str(syn::LitStr::new(&description, field.span())),
attrs: vec![],
}),
}),
};
new_attrs.push(doc_attr);
}
field.attrs = new_attrs;
new_fields.push(field);
}
// Rebuild the struct with the modified fields
let struct_def = quote! {
#(#attrs)*
#vis struct #ident #generics {
#(#new_fields),*
}
};
output.extend(struct_def);
return output.into();
}
// If not a struct with named fields, return an error
syn::Error::new_spanned(
ident,
"stat attribute can only be used on structs with named fields",
)
.to_compile_error()
.into()
}
scx-1.0.12/rust/scx_stats/src/ 0000775 0000000 0000000 00000000000 15007705772 0016201 5 ustar 00root root 0000000 0000000 scx-1.0.12/rust/scx_stats/src/client.rs 0000664 0000000 0000000 00000005374 15007705772 0020036 0 ustar 00root root 0000000 0000000 use crate::{StatsErrno, StatsRequest, StatsResponse};
use anyhow::{anyhow, bail, Result};
use log::trace;
use serde::Deserialize;
use std::io::{BufRead, BufReader, Write};
use std::os::unix::net::UnixStream;
use std::path::{Path, PathBuf};
pub struct StatsClient {
base_path: PathBuf,
sched_path: PathBuf,
stats_path: PathBuf,
path: Option,
stream: Option,
reader: Option>,
}
impl StatsClient {
pub fn new() -> Self {
Self {
base_path: PathBuf::from("/var/run/scx"),
sched_path: PathBuf::from("root"),
stats_path: PathBuf::from("stats"),
path: None,
stream: None,
reader: None,
}
}
pub fn set_base_path>(mut self, path: P) -> Self {
self.base_path = PathBuf::from(path.as_ref());
self
}
pub fn set_sched_path>(mut self, path: P) -> Self {
self.sched_path = PathBuf::from(path.as_ref());
self
}
pub fn set_stats_path>(mut self, path: P) -> Self {
self.stats_path = PathBuf::from(path.as_ref());
self
}
pub fn set_path>(mut self, path: P) -> Self {
self.path = Some(PathBuf::from(path.as_ref()));
self
}
pub fn connect(mut self) -> Result {
if self.path.is_none() {
self.path = Some(self.base_path.join(&self.sched_path).join(&self.stats_path));
}
let path = &self.path.as_ref().unwrap();
let stream = UnixStream::connect(path)?;
self.stream = Some(stream.try_clone()?);
self.reader = Some(BufReader::new(stream));
Ok(self)
}
pub fn send_request(&mut self, req: &StatsRequest) -> Result
where
T: for<'a> Deserialize<'a>,
{
if self.stream.is_none() {
bail!("not connected");
}
let req = serde_json::to_string(&req)? + "\n";
trace!("Sending: {}", req.trim());
self.stream.as_ref().unwrap().write_all(req.as_bytes())?;
let mut line = String::new();
self.reader.as_mut().unwrap().read_line(&mut line)?;
trace!("Received: {}", line.trim());
let mut resp: StatsResponse = serde_json::from_str(&line)?;
let (errno, resp) = (
resp.errno,
resp.args.remove("resp").unwrap_or(serde_json::Value::Null),
);
if errno != 0 {
Err(anyhow!("{}", &resp).context(StatsErrno(errno)))?;
}
Ok(serde_json::from_value(resp)?)
}
pub fn request(&mut self, req: &str, args: Vec<(String, String)>) -> Result
where
T: for<'a> Deserialize<'a>,
{
self.send_request(&StatsRequest::new(req, args))
}
}
scx-1.0.12/rust/scx_stats/src/lib.rs 0000664 0000000 0000000 00000000714 15007705772 0017317 0 ustar 00root root 0000000 0000000 pub use serde_json;
mod stats;
pub use stats::{
Meta, StatsAttr, StatsData, StatsField, StatsFieldAttrs, StatsKind, StatsMeta, StatsMetaAux,
StatsStructAttrs,
};
mod server;
pub use server::{
StatsCloser, StatsErrno, StatsOpener, StatsOps, StatsReader, StatsReaderSend, StatsReaderSync,
StatsRequest, StatsResponse, StatsServer, StatsServerData, ToJson,
};
mod client;
pub use client::StatsClient;
pub mod prelude {
pub use crate::*;
}
scx-1.0.12/rust/scx_stats/src/server.rs 0000664 0000000 0000000 00000051132 15007705772 0020057 0 ustar 00root root 0000000 0000000 use crate::StatsClient;
use crate::{Meta, StatsData, StatsKind, StatsMeta};
use anyhow::{anyhow, bail, Context, Result};
use crossbeam::channel::{unbounded, Receiver, RecvError, Select, SendError, Sender};
use log::{debug, error, warn};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use std::collections::{BTreeMap, BTreeSet};
use std::io::{BufRead, BufReader, Write};
use std::os::unix::net::{UnixListener, UnixStream};
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex};
use std::thread::spawn;
pub trait StatsReader:
FnMut(&BTreeMap, (&Sender, &Receiver)) -> Result
{
}
impl<
Req,
Res,
T: FnMut(&BTreeMap, (&Sender, &Receiver)) -> Result,
> StatsReader for T
{
}
pub trait StatsReaderSend:
FnMut(&BTreeMap, (&Sender, &Receiver)) -> Result + Send
{
}
impl<
Req,
Res,
T: FnMut(&BTreeMap, (&Sender, &Receiver)) -> Result + Send,
> StatsReaderSend for T
{
}
pub trait StatsReaderSync:
Fn(&BTreeMap, (&Sender, &Receiver)) -> Result + Send + Sync
{
}
impl<
Req,
Res,
T: Fn(&BTreeMap, (&Sender, &Receiver)) -> Result
+ Send
+ Sync,
> StatsReaderSync for T
{
}
pub trait StatsOpener:
FnMut((&Sender, &Receiver)) -> Result>> + Send
{
}
impl<
Req,
Res,
T: FnMut((&Sender, &Receiver)) -> Result>> + Send,
> StatsOpener for T
{
}
pub trait StatsCloser: FnOnce((&Sender, &Receiver)) + Send {}
impl, &Receiver)) + Send> StatsCloser for T {}
pub struct StatsOps {
pub open: Box>,
pub close: Option>>,
}
struct StatsOpenOps {
map: BTreeMap<
String,
(
Arc>>,
Box>,
ChannelPair,
),
>,
}
impl StatsOpenOps {
fn new() -> Self {
Self {
map: BTreeMap::new(),
}
}
}
impl std::ops::Drop for StatsOpenOps {
fn drop(&mut self) {
for (_, (ops, _, ch)) in self.map.iter_mut() {
if let Some(close) = ops.lock().unwrap().close.take() {
close((&ch.req, &ch.res));
}
}
}
}
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct StatsRequest {
pub req: String,
#[serde(default)]
pub args: BTreeMap,
}
impl StatsRequest {
pub fn new(req: &str, args: Vec<(String, String)>) -> Self {
Self {
req: req.to_string(),
args: args.into_iter().collect(),
}
}
}
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct StatsResponse {
pub errno: i32,
pub args: BTreeMap,
}
pub struct StatsErrno(pub i32);
impl std::fmt::Display for StatsErrno {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
write!(f, "{}", std::io::Error::from_raw_os_error(self.0))
}
}
impl std::fmt::Debug for StatsErrno {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{:?}", std::io::Error::from_raw_os_error(self.0))
}
}
struct ChannelPair {
req: Sender,
res: Receiver,
}
impl ChannelPair {
fn bidi() -> (ChannelPair, ChannelPair) {
let (req, res) = (unbounded::(), unbounded::());
(
ChannelPair {
req: req.0,
res: res.1,
},
ChannelPair {
req: res.0,
res: req.1,
},
)
}
}
impl Clone for ChannelPair {
fn clone(&self) -> Self {
Self {
req: self.req.clone(),
res: self.res.clone(),
}
}
}
pub struct StatsServerData
where
Req: Send + 'static,
Res: Send + 'static,
{
top: Option,
meta: BTreeMap,
ops: BTreeMap>>>,
}
impl StatsServerData
where
Req: Send + 'static,
Res: Send + 'static,
{
pub fn new() -> Self {
Self {
top: None,
meta: BTreeMap::new(),
ops: BTreeMap::new(),
}
}
pub fn add_meta(mut self, meta: StatsMeta) -> Self {
if meta.attrs.top.is_some() && self.top.is_none() {
self.top = Some(meta.name.clone());
}
self.meta.insert(meta.name.clone(), meta);
self
}
pub fn add_ops(mut self, name: &str, ops: StatsOps) -> Self {
self.ops.insert(name.to_string(), Arc::new(Mutex::new(ops)));
self
}
pub fn add_stats(self, name: &str, fetch: Box>) -> Self {
let wrapped_fetch = Mutex::new(fetch);
let read: Box> =
Box::new(move |args, chan| wrapped_fetch.lock().unwrap()(args, chan));
let wrapped_read = Arc::new(read);
let ops = StatsOps {
open: Box::new(move |_| {
let copy = wrapped_read.clone();
Ok(Box::new(move |args, chan| copy(args, chan)))
}),
close: None,
};
self.add_ops(name, ops)
}
fn visit_meta_inner(
&self,
name: &str,
visit: &mut impl FnMut(&StatsMeta) -> Result<()>,
nesting: &mut BTreeSet,
visited: &mut BTreeSet,
) -> Result<()> {
let m = match self.meta.get(name) {
Some(v) => v,
None => bail!("unknown stats meta name {}", name),
};
if !nesting.insert(name.into()) {
bail!("loop in stats meta detected, {} already nested", name);
}
if !visited.insert(name.into()) {
return Ok(());
}
visit(m)?;
for (fname, field) in m.fields.iter() {
match &field.data {
StatsData::Array(StatsKind::Struct(inner)) => {
self.visit_meta_inner(inner, visit, nesting, visited)?
}
StatsData::Dict {
key: StatsKind::Struct(inner),
datum: _,
} => bail!("{}.{} is a dict with struct {} as key", name, fname, inner),
StatsData::Dict {
key: _,
datum: StatsKind::Struct(inner),
} => self.visit_meta_inner(inner, visit, nesting, visited)?,
_ => {}
}
}
nesting.remove(name);
Ok(())
}
fn visit_meta(
&self,
from: &str,
visit: &mut impl FnMut(&StatsMeta) -> Result<()>,
) -> Result<()> {
let mut nesting = BTreeSet::::new();
let mut visited = BTreeSet::::new();
self.visit_meta_inner(from, visit, &mut nesting, &mut visited)
}
fn verify_meta(&self) -> Result<()> {
if self.top.is_none() {
debug!("top-level stats metadata missing");
return Ok(());
}
// Null visit checks all nested stats are reacheable without loops.
self.visit_meta(self.top.as_ref().unwrap(), &mut |_| Ok(()))
}
pub fn describe_meta(&self, w: &mut W, from: Option<&[&str]>) -> Result<()> {
let meta_names = match from {
Some(v) if !v.is_empty() => v,
Some(_) | None => {
let top = self
.top
.as_ref()
.ok_or_else(|| anyhow!("don't know where to start"))?;
return self.describe_meta_inner(w, top);
}
};
for meta_name in meta_names {
self.describe_meta_inner(w, meta_name)?;
}
Ok(())
}
pub fn describe_meta_inner(&self, w: &mut W, from: &str) -> Result<()> {
let (mut nwidth, mut fwidth, mut dwidth) = (0usize, 0usize, 0usize);
self.visit_meta(from, &mut |m| {
nwidth = nwidth.max(m.name.len());
(fwidth, dwidth) = m.fields.iter().fold((fwidth, dwidth), |acc, (n, f)| {
(acc.0.max(n.len()), acc.1.max(f.data.to_string().len() + 2))
});
Ok(())
})?;
let mut first = true;
self.visit_meta(from, &mut |m| {
if !first {
writeln!(w, "")?;
}
first = false;
write!(w, "[{:nw$}]", m.name, nw = nwidth)?;
if let Some(desc) = &m.attrs.desc {
write!(w, " {}", desc)?;
}
writeln!(w, "")?;
for (fname, f) in m.fields.iter() {
write!(
w,
" {:fw$} {:dw$}",
fname,
format!("({})", f.data.to_string()),
fw = fwidth,
dw = dwidth
)?;
if let Some(desc) = &f.attrs.desc {
write!(w, " : {}", desc)?;
}
writeln!(w, "")?;
}
Ok(())
})
}
}
struct StatsServerInner
where
Req: Send + 'static,
Res: Send + 'static,
{
listener: UnixListener,
data: Arc>>,
inner_ch: ChannelPair,
exit: Arc,
}
impl StatsServerInner
where
Req: Send + 'static,
Res: Send + 'static,
{
fn new(
listener: UnixListener,
data: Arc>>,
inner_ch: ChannelPair,
exit: Arc,
) -> Self {
Self {
listener,
data,
inner_ch,
exit,
}
}
fn build_resp(errno: i32, resp: &T) -> Result
where
T: Serialize,
{
Ok(StatsResponse {
errno,
args: [("resp".into(), serde_json::to_value(resp)?)]
.into_iter()
.collect(),
})
}
fn handle_request(
line: String,
data: &Arc>>,
ch: &ChannelPair,
open_ops: &mut StatsOpenOps,
) -> Result {
let req: StatsRequest = serde_json::from_str(&line)?;
match req.req.as_str() {
"stats" => {
let target = match req.args.get("target") {
Some(v) => v,
None => "top",
};
let ops =
match data.lock().unwrap().ops.get(target) {
Some(v) => v.clone(),
None => Err(anyhow!("unknown stat target {:?}", req)
.context(StatsErrno(libc::EINVAL)))?,
};
if !open_ops.map.contains_key(target) {
let read = (ops.lock().unwrap().open)((&ch.req, &ch.res))?;
open_ops
.map
.insert(target.into(), (ops.clone(), read, ch.clone()));
}
let read = &mut open_ops.map.get_mut(target).unwrap().1;
let resp = read(&req.args, (&ch.req, &ch.res))?;
Self::build_resp(0, &resp)
}
"stats_meta" => Ok(Self::build_resp(0, &data.lock().unwrap().meta)?),
req => Err(anyhow!("unknown command {:?}", req).context(StatsErrno(libc::EINVAL)))?,
}
}
fn serve(
mut stream: UnixStream,
data: Arc