YGGverse/aquatic
1
0
Fork 0
mirror of https://github.com/YGGverse/aquatic.git synced 2026-03-31 17:55:36 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Improve CPU pinning

Browse source
This commit is contained in:
Joakim Frostegård 2022-03-30 22:33:23 +02:00
parent 5057ba73bd
commit fb607ac0c2
20 changed files with 219 additions and 143 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Cargo.lock generated
View file

@ -75,6 +75,7 @@ dependencies = [
"anyhow",
"aquatic_toml_config",
"arc-swap",
"glommio",
"hashbrown 0.12.0",
"hex",
"hwloc",
@ -101,6 +102,7 @@ dependencies = [
"futures-rustls",
"glommio",
"itoa 1.0.1",
"libc",
"log",
"memchr",
"mimalloc",

8
aquatic_common/Cargo.toml
View file

@ -12,7 +12,8 @@ readme = "../README.md"
name = "aquatic_common"
[features]
cpu-pinning = ["hwloc", "libc"]
with-glommio = ["glommio"]
with-hwloc = ["hwloc"]
[dependencies]
aquatic_toml_config = "0.2.0"
@ -23,11 +24,12 @@ arc-swap = "1"
hashbrown = "0.12"
hex = "0.4"
indexmap-amortized = "1"
libc = "0.2"
log = "0.4"
privdrop = "0.5"
rand = { version = "0.8", features = ["small_rng"] }
serde = { version = "1", features = ["derive"] }
# cpu-pinning
# Optional
glommio = { version = "0.7", optional = true }
hwloc = { version = "0.5", optional = true }
libc = { version = "0.2", optional = true }

114
aquatic_common/src/cpu_pinning.rs
View file

@ -1,5 +1,4 @@
use aquatic_toml_config::TomlConfig;
use hwloc::{CpuSet, ObjectType, Topology, CPUBIND_THREAD};
use serde::{Deserialize, Serialize};
#[derive(Clone, Debug, PartialEq, TomlConfig, Serialize, Deserialize)]
@ -15,6 +14,7 @@ impl Default for CpuPinningMode {
}
}
/// Experimental CPU pinning
#[derive(Clone, Debug, PartialEq, TomlConfig, Deserialize)]
pub struct CpuPinningConfig {
pub active: bool,
@ -45,37 +45,128 @@ impl CpuPinningConfig {
pub enum WorkerIndex {
SocketWorker(usize),
RequestWorker(usize),
Other,
Util,
}
impl WorkerIndex {
fn get_core_index(
self,
pub fn get_core_index(
&self,
config: &CpuPinningConfig,
socket_workers: usize,
core_count: usize,
request_workers: usize,
num_cores: usize,
) -> usize {
let ascending_index = match self {
Self::Other => config.core_offset,
Self::SocketWorker(index) => config.core_offset + 1 + index,
Self::RequestWorker(index) => config.core_offset + 1 + socket_workers + index,
Self::SocketWorker(index) => config.core_offset + index,
Self::RequestWorker(index) => config.core_offset + socket_workers + index,
Self::Util => config.core_offset + socket_workers + request_workers,
};
let max_core_index = num_cores - 1;
let ascending_index = ascending_index.min(max_core_index);
match config.mode {
CpuPinningMode::Ascending => ascending_index,
CpuPinningMode::Descending => core_count - 1 - ascending_index,
CpuPinningMode::Descending => max_core_index - ascending_index,
}
}
}
#[cfg(feature = "with-glommio")]
pub mod glommio {
use ::glommio::{CpuSet, Placement};
use super::*;
fn get_cpu_set() -> anyhow::Result<CpuSet> {
CpuSet::online().map_err(|err| anyhow::anyhow!("Couldn't get CPU set: {:#}", err))
}
fn get_num_cpu_cores() -> anyhow::Result<usize> {
get_cpu_set()?
.iter()
.map(|l| l.core)
.max()
.ok_or(anyhow::anyhow!("CpuSet is empty"))
}
fn get_worker_cpu_set(
config: &CpuPinningConfig,
socket_workers: usize,
request_workers: usize,
worker_index: WorkerIndex,
) -> anyhow::Result<CpuSet> {
let num_cpu_cores = get_num_cpu_cores()?;
let core_index =
worker_index.get_core_index(&config, socket_workers, request_workers, num_cpu_cores);
Ok(get_cpu_set()?.filter(|l| l.core == core_index))
}
pub fn get_worker_placement(
config: &CpuPinningConfig,
socket_workers: usize,
request_workers: usize,
worker_index: WorkerIndex,
) -> anyhow::Result<Placement> {
if config.active {
let cpu_set =
get_worker_cpu_set(&config, socket_workers, request_workers, worker_index)?;
Ok(Placement::Fenced(cpu_set))
} else {
Ok(Placement::Unbound)
}
}
pub fn set_affinity_for_util_worker(
config: &CpuPinningConfig,
socket_workers: usize,
request_workers: usize,
) -> anyhow::Result<()> {
let worker_cpu_set =
get_worker_cpu_set(&config, socket_workers, request_workers, WorkerIndex::Util)?;
let logical_cpus: Vec<usize> = worker_cpu_set.iter().map(|l| l.cpu).collect();
unsafe {
let mut set: libc::cpu_set_t = ::std::mem::zeroed();
for cpu in logical_cpus {
libc::CPU_SET(cpu, &mut set);
}
let status = libc::pthread_setaffinity_np(
libc::pthread_self(),
::std::mem::size_of::<libc::cpu_set_t>(),
&set,
);
if status != 0 {
return Err(anyhow::Error::new(::std::io::Error::from_raw_os_error(
status,
)));
}
}
Ok(())
}
}
/// Pin current thread to a suitable core
///
/// Requires hwloc (`apt-get install libhwloc-dev`)
#[cfg(feature = "with-hwloc")]
pub fn pin_current_if_configured_to(
config: &CpuPinningConfig,
socket_workers: usize,
request_workers: usize,
worker_index: WorkerIndex,
) {
use hwloc::{CpuSet, ObjectType, Topology, CPUBIND_THREAD};
if config.active {
let mut topology = Topology::new();
@ -86,7 +177,10 @@ pub fn pin_current_if_configured_to(
.map(|core| core.allowed_cpuset().expect("hwloc: get core cpu set"))
.collect();
let core_index = worker_index.get_core_index(config, socket_workers, core_cpu_sets.len());
let num_cores = core_cpu_sets.len();
let core_index =
worker_index.get_core_index(config, socket_workers, request_workers, num_cores);
let cpu_set = core_cpu_sets
.get(core_index)

1
aquatic_common/src/lib.rs
View file

@ -5,7 +5,6 @@ use ahash::RandomState;
use rand::Rng;
pub mod access_list;
#[cfg(feature = "cpu-pinning")]
pub mod cpu_pinning;
pub mod privileges;

6
aquatic_http/Cargo.toml
View file

@ -15,12 +15,9 @@ name = "aquatic_http"
[[bin]]
name = "aquatic_http"
[features]
cpu-pinning = ["aquatic_common/cpu-pinning"]
[dependencies]
aquatic_cli_helpers = "0.2.0"
aquatic_common = "0.2.0"
aquatic_common = { version = "0.2.0", features = ["with-glommio"] }
aquatic_http_protocol = "0.2.0"
aquatic_toml_config = "0.2.0"
@ -31,6 +28,7 @@ futures-lite = "1"
futures-rustls = "0.22"
glommio = "0.7"
itoa = "1"
libc = "0.2"
log = "0.4"
mimalloc = { version = "0.1", default-features = false }
memchr = "2"

2
aquatic_http/src/config.rs
View file

@ -23,7 +23,6 @@ pub struct Config {
pub cleaning: CleaningConfig,
pub privileges: PrivilegeConfig,
pub access_list: AccessListConfig,
#[cfg(feature = "cpu-pinning")]
pub cpu_pinning: aquatic_common::cpu_pinning::CpuPinningConfig,
}
@ -38,7 +37,6 @@ impl Default for Config {
cleaning: CleaningConfig::default(),
privileges: PrivilegeConfig::default(),
access_list: AccessListConfig::default(),
#[cfg(feature = "cpu-pinning")]
cpu_pinning: Default::default(),
}
}

65
aquatic_http/src/lib.rs
View file

@ -1,7 +1,10 @@
#[cfg(feature = "cpu-pinning")]
use aquatic_common::cpu_pinning::{pin_current_if_configured_to, WorkerIndex};
use aquatic_common::{
access_list::update_access_list, privileges::drop_privileges_after_socket_binding,
access_list::update_access_list,
cpu_pinning::{
glommio::{get_worker_placement, set_affinity_for_util_worker},
WorkerIndex,
},
privileges::drop_privileges_after_socket_binding,
};
use common::{State, TlsConfig};
use glommio::{channels::channel_mesh::MeshBuilder, prelude::*};
@ -37,12 +40,13 @@ pub fn run(config: Config) -> ::anyhow::Result<()> {
::std::thread::spawn(move || run_inner(config, state));
}
#[cfg(feature = "cpu-pinning")]
pin_current_if_configured_to(
&config.cpu_pinning,
config.socket_workers,
WorkerIndex::Other,
);
if config.cpu_pinning.active {
set_affinity_for_util_worker(
&config.cpu_pinning,
config.socket_workers,
config.request_workers,
)?;
}
for signal in &mut signals {
match signal {
@ -76,16 +80,15 @@ pub fn run_inner(config: Config, state: State) -> anyhow::Result<()> {
let response_mesh_builder = response_mesh_builder.clone();
let num_bound_sockets = num_bound_sockets.clone();
let builder = LocalExecutorBuilder::default().name("socket");
let placement = get_worker_placement(
&config.cpu_pinning,
config.socket_workers,
config.request_workers,
WorkerIndex::SocketWorker(i),
)?;
let builder = LocalExecutorBuilder::new(placement).name("socket");
let executor = builder.spawn(move || async move {
#[cfg(feature = "cpu-pinning")]
pin_current_if_configured_to(
&config.cpu_pinning,
config.socket_workers,
WorkerIndex::SocketWorker(i),
);
workers::socket::run_socket_worker(
config,
state,
@ -106,16 +109,15 @@ pub fn run_inner(config: Config, state: State) -> anyhow::Result<()> {
let request_mesh_builder = request_mesh_builder.clone();
let response_mesh_builder = response_mesh_builder.clone();
let builder = LocalExecutorBuilder::default().name("request");
let placement = get_worker_placement(
&config.cpu_pinning,
config.socket_workers,
config.request_workers,
WorkerIndex::RequestWorker(i),
)?;
let builder = LocalExecutorBuilder::new(placement).name("request");
let executor = builder.spawn(move || async move {
#[cfg(feature = "cpu-pinning")]
pin_current_if_configured_to(
&config.cpu_pinning,
config.socket_workers,
WorkerIndex::RequestWorker(i),
);
workers::request::run_request_worker(
config,
state,
@ -135,12 +137,13 @@ pub fn run_inner(config: Config, state: State) -> anyhow::Result<()> {
)
.unwrap();
#[cfg(feature = "cpu-pinning")]
pin_current_if_configured_to(
&config.cpu_pinning,
config.socket_workers,
WorkerIndex::Other,
);
if config.cpu_pinning.active {
set_affinity_for_util_worker(
&config.cpu_pinning,
config.socket_workers,
config.request_workers,
)?;
}
for executor in executors {
executor

5
aquatic_http_load_test/Cargo.toml
View file

@ -12,12 +12,9 @@ readme = "../README.md"
[[bin]]
name = "aquatic_http_load_test"
[features]
cpu-pinning = ["aquatic_common/cpu-pinning"]
[dependencies]
aquatic_cli_helpers = "0.2.0"
aquatic_common = "0.2.0"
aquatic_common = { version = "0.2.0", features = ["with-glommio"] }
aquatic_http_protocol = "0.2.0"
aquatic_toml_config = "0.2.0"

2
aquatic_http_load_test/src/config.rs
View file

@ -20,7 +20,6 @@ pub struct Config {
pub connection_creation_interval_ms: u64,
pub duration: usize,
pub torrents: TorrentConfig,
#[cfg(feature = "cpu-pinning")]
pub cpu_pinning: aquatic_common::cpu_pinning::CpuPinningConfig,
}
@ -58,7 +57,6 @@ impl Default for Config {
connection_creation_interval_ms: 10,
duration: 0,
torrents: TorrentConfig::default(),
#[cfg(feature = "cpu-pinning")]
cpu_pinning: aquatic_common::cpu_pinning::CpuPinningConfig::default_for_load_test(),
}
}

31
aquatic_http_load_test/src/main.rs
View file

@ -3,8 +3,8 @@ use std::thread;
use std::time::{Duration, Instant};
use ::glommio::LocalExecutorBuilder;
#[cfg(feature = "cpu-pinning")]
use aquatic_common::cpu_pinning::{pin_current_if_configured_to, WorkerIndex};
use aquatic_common::cpu_pinning::glommio::{get_worker_placement, set_affinity_for_util_worker};
use aquatic_common::cpu_pinning::WorkerIndex;
use rand::prelude::*;
use rand_distr::Pareto;
@ -55,8 +55,6 @@ fn run(config: Config) -> ::anyhow::Result<()> {
pareto: Arc::new(pareto),
};
// Start socket workers
let tls_config = create_tls_config().unwrap();
for i in 0..config.num_workers {
@ -64,26 +62,23 @@ fn run(config: Config) -> ::anyhow::Result<()> {
let tls_config = tls_config.clone();
let state = state.clone();
LocalExecutorBuilder::default()
.spawn(move || async move {
#[cfg(feature = "cpu-pinning")]
pin_current_if_configured_to(
&config.cpu_pinning,
config.num_workers,
WorkerIndex::SocketWorker(i),
);
let placement = get_worker_placement(
&config.cpu_pinning,
config.num_workers,
0,
WorkerIndex::SocketWorker(i),
)?;
LocalExecutorBuilder::new(placement)
.spawn(move || async move {
run_socket_thread(config, tls_config, state).await.unwrap();
})
.unwrap();
}
#[cfg(feature = "cpu-pinning")]
pin_current_if_configured_to(
&config.cpu_pinning,
config.num_workers as usize,
WorkerIndex::Other,
);
if config.cpu_pinning.active {
set_affinity_for_util_worker(&config.cpu_pinning, config.num_workers, 0)?;
}
monitor_statistics(state, &config);

2
aquatic_udp/Cargo.toml
View file

@ -16,7 +16,7 @@ name = "aquatic_udp"
name = "aquatic_udp"
[features]
cpu-pinning = ["aquatic_common/cpu-pinning"]
cpu-pinning = ["aquatic_common/with-hwloc"]
[dependencies]
aquatic_cli_helpers = "0.2.0"

8
aquatic_udp/src/lib.rs
View file

@ -75,6 +75,7 @@ pub fn run(config: Config) -> ::anyhow::Result<()> {
pin_current_if_configured_to(
&config.cpu_pinning,
config.socket_workers,
config.request_workers,
WorkerIndex::RequestWorker(i),
);
@ -104,6 +105,7 @@ pub fn run(config: Config) -> ::anyhow::Result<()> {
pin_current_if_configured_to(
&config.cpu_pinning,
config.socket_workers,
config.request_workers,
WorkerIndex::SocketWorker(i),
);
@ -130,7 +132,8 @@ pub fn run(config: Config) -> ::anyhow::Result<()> {
pin_current_if_configured_to(
&config.cpu_pinning,
config.socket_workers,
WorkerIndex::Other,
config.request_workers,
WorkerIndex::Util,
);
workers::statistics::run_statistics_worker(config, state);
@ -149,7 +152,8 @@ pub fn run(config: Config) -> ::anyhow::Result<()> {
pin_current_if_configured_to(
&config.cpu_pinning,
config.socket_workers,
WorkerIndex::Other,
config.request_workers,
WorkerIndex::Util,
);
for signal in &mut signals {

6
aquatic_udp_load_test/Cargo.toml
View file

@ -9,12 +9,12 @@ repository = "https://github.com/greatest-ape/aquatic"
keywords = ["udp", "benchmark", "peer-to-peer", "torrent", "bittorrent"]
readme = "../README.md"
[features]
cpu-pinning = ["aquatic_common/with-hwloc"]
[[bin]]
name = "aquatic_udp_load_test"
[features]
cpu-pinning = ["aquatic_common/cpu-pinning"]
[dependencies]
aquatic_cli_helpers = "0.2.0"
aquatic_common = "0.2.0"

4
aquatic_udp_load_test/src/main.rs
View file

@ -84,6 +84,7 @@ fn run(config: Config) -> ::anyhow::Result<()> {
pin_current_if_configured_to(
&config.cpu_pinning,
config.workers as usize,
0,
WorkerIndex::SocketWorker(i as usize),
);
@ -95,7 +96,8 @@ fn run(config: Config) -> ::anyhow::Result<()> {
pin_current_if_configured_to(
&config.cpu_pinning,
config.workers as usize,
WorkerIndex::Other,
0,
WorkerIndex::Util,
);
monitor_statistics(state, &config);

6
aquatic_ws/Cargo.toml
View file

@ -9,19 +9,15 @@ repository = "https://github.com/greatest-ape/aquatic"
keywords = ["webtorrent", "websocket", "peer-to-peer", "torrent", "bittorrent"]
readme = "../README.md"
[lib]
name = "aquatic_ws"
[[bin]]
name = "aquatic_ws"
[features]
cpu-pinning = ["aquatic_common/cpu-pinning"]
[dependencies]
aquatic_cli_helpers = "0.2.0"
aquatic_common = "0.2.0"
aquatic_common = { version = "0.2.0", features = ["with-glommio"] }
aquatic_toml_config = "0.2.0"
aquatic_ws_protocol = "0.2.0"

3
aquatic_ws/src/config.rs
View file

@ -1,7 +1,6 @@
use std::net::SocketAddr;
use std::path::PathBuf;
#[cfg(feature = "cpu-pinning")]
use aquatic_common::cpu_pinning::CpuPinningConfig;
use aquatic_common::{access_list::AccessListConfig, privileges::PrivilegeConfig};
use serde::Deserialize;
@ -26,7 +25,6 @@ pub struct Config {
pub cleaning: CleaningConfig,
pub privileges: PrivilegeConfig,
pub access_list: AccessListConfig,
#[cfg(feature = "cpu-pinning")]
pub cpu_pinning: CpuPinningConfig,
}
@ -41,7 +39,6 @@ impl Default for Config {
cleaning: CleaningConfig::default(),
privileges: PrivilegeConfig::default(),
access_list: AccessListConfig::default(),
#[cfg(feature = "cpu-pinning")]
cpu_pinning: Default::default(),
}
}

60
aquatic_ws/src/lib.rs
View file

@ -6,12 +6,12 @@ use std::fs::File;
use std::io::BufReader;
use std::sync::{atomic::AtomicUsize, Arc};
use aquatic_common::cpu_pinning::glommio::{get_worker_placement, set_affinity_for_util_worker};
use aquatic_common::cpu_pinning::WorkerIndex;
use glommio::{channels::channel_mesh::MeshBuilder, prelude::*};
use signal_hook::{consts::SIGUSR1, iterator::Signals};
use aquatic_common::access_list::update_access_list;
#[cfg(feature = "cpu-pinning")]
use aquatic_common::cpu_pinning::{pin_current_if_configured_to, WorkerIndex};
use aquatic_common::privileges::drop_privileges_after_socket_binding;
use common::*;
@ -36,12 +36,13 @@ pub fn run(config: Config) -> ::anyhow::Result<()> {
::std::thread::spawn(move || run_workers(config, state));
}
#[cfg(feature = "cpu-pinning")]
pin_current_if_configured_to(
&config.cpu_pinning,
config.socket_workers,
WorkerIndex::Other,
);
if config.cpu_pinning.active {
set_affinity_for_util_worker(
&config.cpu_pinning,
config.socket_workers,
config.request_workers,
)?;
}
for signal in &mut signals {
match signal {
@ -75,16 +76,15 @@ fn run_workers(config: Config, state: State) -> anyhow::Result<()> {
let response_mesh_builder = response_mesh_builder.clone();
let num_bound_sockets = num_bound_sockets.clone();
let builder = LocalExecutorBuilder::default().name("socket");
let placement = get_worker_placement(
&config.cpu_pinning,
config.socket_workers,
config.request_workers,
WorkerIndex::SocketWorker(i),
)?;
let builder = LocalExecutorBuilder::new(placement).name("socket");
let executor = builder.spawn(move || async move {
#[cfg(feature = "cpu-pinning")]
pin_current_if_configured_to(
&config.cpu_pinning,
config.socket_workers,
WorkerIndex::SocketWorker(i),
);
workers::socket::run_socket_worker(
config,
state,
@ -105,16 +105,15 @@ fn run_workers(config: Config, state: State) -> anyhow::Result<()> {
let request_mesh_builder = request_mesh_builder.clone();
let response_mesh_builder = response_mesh_builder.clone();
let builder = LocalExecutorBuilder::default().name("request");
let placement = get_worker_placement(
&config.cpu_pinning,
config.socket_workers,
config.request_workers,
WorkerIndex::RequestWorker(i),
)?;
let builder = LocalExecutorBuilder::new(placement).name("request");
let executor = builder.spawn(move || async move {
#[cfg(feature = "cpu-pinning")]
pin_current_if_configured_to(
&config.cpu_pinning,
config.socket_workers,
WorkerIndex::RequestWorker(i),
);
workers::request::run_request_worker(
config,
state,
@ -134,12 +133,13 @@ fn run_workers(config: Config, state: State) -> anyhow::Result<()> {
)
.unwrap();
#[cfg(feature = "cpu-pinning")]
pin_current_if_configured_to(
&config.cpu_pinning,
config.socket_workers,
WorkerIndex::Other,
);
if config.cpu_pinning.active {
set_affinity_for_util_worker(
&config.cpu_pinning,
config.socket_workers,
config.request_workers,
)?;
}
for executor in executors {
executor

5
aquatic_ws_load_test/Cargo.toml
View file

@ -12,13 +12,10 @@ readme = "../README.md"
[[bin]]
name = "aquatic_ws_load_test"
[features]
cpu-pinning = ["aquatic_common/cpu-pinning"]
[dependencies]
async-tungstenite = "0.17"
aquatic_cli_helpers = "0.2.0"
aquatic_common = "0.2.0"
aquatic_common = { version = "0.2.0", features = ["with-glommio"] }
aquatic_toml_config = "0.2.0"
aquatic_ws_protocol = "0.2.0"

3
aquatic_ws_load_test/src/config.rs
View file

@ -1,7 +1,6 @@
use std::net::SocketAddr;
use aquatic_cli_helpers::LogLevel;
#[cfg(feature = "cpu-pinning")]
use aquatic_common::cpu_pinning::CpuPinningConfig;
use aquatic_toml_config::TomlConfig;
use serde::Deserialize;
@ -17,7 +16,6 @@ pub struct Config {
pub connection_creation_interval_ms: u64,
pub duration: usize,
pub torrents: TorrentConfig,
#[cfg(feature = "cpu-pinning")]
pub cpu_pinning: CpuPinningConfig,
}
@ -37,7 +35,6 @@ impl Default for Config {
connection_creation_interval_ms: 10,
duration: 0,
torrents: TorrentConfig::default(),
#[cfg(feature = "cpu-pinning")]
cpu_pinning: CpuPinningConfig::default_for_load_test(),
}
}

29
aquatic_ws_load_test/src/main.rs
View file

@ -2,8 +2,8 @@ use std::sync::{atomic::Ordering, Arc};
use std::thread;
use std::time::{Duration, Instant};
#[cfg(feature = "cpu-pinning")]
use aquatic_common::cpu_pinning::{pin_current_if_configured_to, WorkerIndex};
use aquatic_common::cpu_pinning::glommio::{get_worker_placement, set_affinity_for_util_worker};
use aquatic_common::cpu_pinning::WorkerIndex;
use glommio::LocalExecutorBuilder;
use rand::prelude::*;
use rand_distr::Pareto;
@ -59,26 +59,23 @@ fn run(config: Config) -> ::anyhow::Result<()> {
let tls_config = tls_config.clone();
let state = state.clone();
LocalExecutorBuilder::default()
.spawn(move || async move {
#[cfg(feature = "cpu-pinning")]
pin_current_if_configured_to(
&config.cpu_pinning,
config.num_workers,
WorkerIndex::SocketWorker(i),
);
let placement = get_worker_placement(
&config.cpu_pinning,
config.num_workers,
0,
WorkerIndex::SocketWorker(i),
)?;
LocalExecutorBuilder::new(placement)
.spawn(move || async move {
run_socket_thread(config, tls_config, state).await.unwrap();
})
.unwrap();
}
#[cfg(feature = "cpu-pinning")]
pin_current_if_configured_to(
&config.cpu_pinning,
config.num_workers as usize,
WorkerIndex::Other,
);
if config.cpu_pinning.active {
set_affinity_for_util_worker(&config.cpu_pinning, config.num_workers, 0)?;
}
monitor_statistics(state, &config);