fix: rename kick thread config to nice

Rename the kick thread scheduling configuration to `kick_kern_nice` and
clarify Linux nice semantics as `[-20, 19]`, where lower values indicate
higher priority.

Remove references to SCHED_FIFO, as this setting now controls a
nice-based priority. Realtime scheduling requires extra privileges and
host tuning (e.g., `kernel.sched_rt_runtime_us`) and can interfere with
production workloads. Using nice ensures safe, container-compatible
thread prioritization.

Author: yinjiping

agent/src/config/config.rs

@@ -1238,7 +1238,7 @@ pub struct EbpfProfile {
 pub struct EbpfTunning {
     pub collector_queue_size: usize,
     pub userspace_worker_threads: i32,
-    pub kick_kern_sched_priority: u32,
+    pub kick_kern_nice: i32,
     pub perf_pages_count: u32,
     pub kernel_ring_size: u32,
     pub max_socket_entries: u32,
@@ -1251,7 +1251,7 @@ impl Default for EbpfTunning {
         Self {
             collector_queue_size: 65535,
             userspace_worker_threads: 1,
-            kick_kern_sched_priority: 1,
+            kick_kern_nice: 0,
             perf_pages_count: 128,
             kernel_ring_size: 65536,
             max_socket_entries: 131072,
@@ -1263,10 +1263,10 @@ impl Default for EbpfTunning {
 
 impl EbpfTunning {
     pub(crate) fn validate(&self) -> Result<(), String> {
-        if !(1..=99).contains(&self.kick_kern_sched_priority) {
+        if !(-20..=19).contains(&self.kick_kern_nice) {
             return Err(format!(
-                "kick_kern_sched_priority {} not in [1, 99]",
-                self.kick_kern_sched_priority
+                "kick_kern_nice {} not in [-20, 19]",
+                self.kick_kern_nice
             ));
         }
 

agent/src/config/handler.rs

@@ -3813,12 +3813,12 @@ impl ConfigHandler {
             tunning.kernel_ring_size = new_tunning.kernel_ring_size;
             restart_agent = !first_run;
         }
-        if tunning.kick_kern_sched_priority != new_tunning.kick_kern_sched_priority {
+        if tunning.kick_kern_nice != new_tunning.kick_kern_nice {
             info!(
-                "Update inputs.ebpf.tunning.kick_kern_sched_priority from {:?} to {:?}.",
-                tunning.kick_kern_sched_priority, new_tunning.kick_kern_sched_priority
+                "Update inputs.ebpf.tunning.kick_kern_nice from {:?} to {:?}.",
+                tunning.kick_kern_nice, new_tunning.kick_kern_nice
             );
-            tunning.kick_kern_sched_priority = new_tunning.kick_kern_sched_priority;
+            tunning.kick_kern_nice = new_tunning.kick_kern_nice;
             restart_agent = !first_run;
         }
         if tunning.max_socket_entries != new_tunning.max_socket_entries {

agent/src/ebpf/mod.rs

@@ -648,7 +648,7 @@ extern "C" {
     //            false Define a map without preallocated memory
     pub fn set_bpf_map_prealloc(enabled: bool) -> c_void;
 
-    pub fn set_kick_kern_sched_priority(priority: c_uint) -> c_int;
+    pub fn set_kick_kern_nice(nice: c_int) -> c_int;
 
     // Parameter descriptions:
     // callback: Callback interface from Rust to C; return values refer to definitions of TRACER_CALLBACK_FLAG_*.

agent/src/ebpf/user/config.h

@@ -328,11 +328,11 @@ enum cfg_feature_idx {
  */
 #define KICK_KERN_PERIOD 40000000  // Set default interval to 40 milliseconds
 /*
- * Default realtime scheduling priority for per-CPU kick threads.
+ * Default CFS nice value for per-CPU kick threads.
  *
- * The actual priority can be overridden at startup by configuration.
+ * The actual nice value can be overridden at startup by configuration.
  */
-#define KICK_KERN_SCHED_PRIORITY 1
+#define KICK_KERN_NICE 0
 
 /*
  * A special value should be assigned to indicate the case where no data has

agent/src/ebpf/user/tracer.c

@@ -66,7 +66,7 @@ char linux_release[128];	// Record the contents of 'uname -r'
  * Used to manage or inspect per-CPU kick threads.
  */
 kick_thread_info_t kick_threads[MAX_CPU_NR];
-static uint32_t kick_kern_sched_priority = KICK_KERN_SCHED_PRIORITY;
+static int32_t kick_kern_nice = KICK_KERN_NICE;
 volatile uint32_t *tracers_lock;
 extern volatile uint64_t sys_boot_time_ns;	// System boot time in nanoseconds
 volatile uint64_t prev_sys_boot_time_ns;	// The last updated system boot time, in nanoseconds
@@ -1648,13 +1648,13 @@ static int boot_time_update(void)
  * The following method triggers a timeout check on all CPUs
  * to push data residing in the eBPF buffer.
  */
-int set_kick_kern_sched_priority(uint32_t priority)
+int set_kick_kern_nice(int32_t nice)
 {
-	if (priority == 0)
+	if (nice < -20 || nice > 19)
 		return ETR_INVAL;
 
-	kick_kern_sched_priority = priority;
-	ebpf_info("Set kick thread SCHED_FIFO priority to %u.\n", priority);
+	kick_kern_nice = nice;
+	ebpf_info("Set kick thread nice value to %d.\n", nice);
 	return 0;
 }
 
@@ -1722,25 +1722,24 @@ static void *kick_kern_push_data(void *arg)
 	}
 
 	/*
-	 * Use a low SCHED_FIFO priority from startup configuration for the per-CPU
-	 * kick thread.
+	 * Keep the kick thread on the default SCHED_OTHER/CFS policy and adjust
+	 * only its Linux nice value.
 	 *
-	 * This thread wakes up periodically and issues a lightweight syscall to
-	 * trigger kernel-side timeout checks that flush batched eBPF data. Under
-	 * CPU contention, the default CFS scheduler may delay the dispatch of this
-	 * thread after the timer expires, which increases the actual kick interval.
-	 * Switching to SCHED_FIFO with a low priority helps reduce this wakeup
-	 * latency while limiting interference with other workloads.
+	 * A smaller nice value gives the thread more scheduling preference under
+	 * CPU contention, while a larger value gives it less. Negative values may
+	 * require CAP_SYS_NICE or a sufficient RLIMIT_NICE.
 	 */
-	struct sched_param sched_param = {
-		.sched_priority = kick_kern_sched_priority,
-	};
-	if (pthread_setschedparam(pthread_self(), SCHED_FIFO, &sched_param) != 0) {
-		ebpf_warning("Kick thread %d failed to set SCHED_FIFO priority %d: %s(%d)\n",
-			     tid, sched_param.sched_priority, strerror(errno), errno);
+	if (setpriority(PRIO_PROCESS, tid, kick_kern_nice) != 0) {
+		if (kick_kern_nice < 0 && (errno == EACCES || errno == EPERM)) {
+			ebpf_warning("Kick thread %d failed to set nice value %d and will continue with default CFS priority; CAP_SYS_NICE or RLIMIT_NICE may be required: %s(%d)\n",
+				     tid, kick_kern_nice, strerror(errno), errno);
+		} else {
+			ebpf_warning("Kick thread %d failed to set nice value %d and will continue with default CFS priority: %s(%d)\n",
+				     tid, kick_kern_nice, strerror(errno), errno);
+		}
 	} else {
-		ebpf_info("Kick thread %d set SCHED_FIFO priority %d.\n",
-			  tid, sched_param.sched_priority);
+		ebpf_info("Kick thread %d set nice value %d.\n", tid,
+			  kick_kern_nice);
 	}
 
 	struct epoll_event events[1];

agent/src/ebpf/user/tracer.h

@@ -630,7 +630,7 @@ bool php_profiler_enabled(void);
 bool v8_profiler_enabled(void);
 bool python_profiler_enabled(void);
 int bpf_tracer_init(const char *log_file, bool is_stdout);
-int set_kick_kern_sched_priority(uint32_t priority);
+int set_kick_kern_nice(int32_t nice);
 int tracer_bpf_load(struct bpf_tracer *tracer);
 int tracer_probes_init(struct bpf_tracer *tracer);
 int tracer_hooks_attach(struct bpf_tracer *tracer);

agent/src/ebpf_dispatcher.rs

@@ -1021,15 +1021,13 @@ impl EbpfCollector {
 
         if let Err(e) = config.ebpf.tunning.validate() {
             warn!(
-                "skip setting kick thread SCHED_FIFO priority to {}: {}",
-                config.ebpf.tunning.kick_kern_sched_priority, e
+                "skip setting kick thread nice value to {}: {}",
+                config.ebpf.tunning.kick_kern_nice, e
             );
-        } else if ebpf::set_kick_kern_sched_priority(config.ebpf.tunning.kick_kern_sched_priority)
-            != 0
-        {
+        } else if ebpf::set_kick_kern_nice(config.ebpf.tunning.kick_kern_nice) != 0 {
             warn!(
-                "failed to set kick thread SCHED_FIFO priority to {}",
-                config.ebpf.tunning.kick_kern_sched_priority
+                "failed to set kick thread nice value to {}",
+                config.ebpf.tunning.kick_kern_nice
             );
         }
 

server/agent_config/README-CH.md

@@ -5593,44 +5593,45 @@ inputs:
 
 参与用户态数据处理的工作线程数量。实际最大值为主机 CPU 逻辑核心数。
 
-#### Kick 线程 FIFO 优先级 {#inputs.ebpf.tunning.kick_kern_sched_priority}
+#### Kick 线程 Nice 值 {#inputs.ebpf.tunning.kick_kern_nice}
 
 **标签**:
 
 <mark>agent_restart</mark>
 
 **FQCN**:
 
-`inputs.ebpf.tunning.kick_kern_sched_priority`
+`inputs.ebpf.tunning.kick_kern_nice`
 
 **默认值**:
 ```yaml
 inputs:
   ebpf:
     tunning:
-      kick_kern_sched_priority: 1
+      kick_kern_nice: 0
 ```
 
 **模式**:
 | Key  | Value                        |
 | ---- | ---------------------------- |
 | Type | int |
-| Range | [1, 99] |
+| Range | [-20, 19] |
 
 **详细描述**:
 
-控制每个 CPU 上 kick 线程的 SCHED_FIFO 优先级。
+控制每个 CPU 上 kick 线程使用的 Linux nice 值。
 
 这些线程会在周期性定时器到期后唤醒，并通过轻量级 syscall
 触发内核侧超时检查，将批量 eBPF 数据从缓冲区中推送出来。
 
 当“指标中心”中 `deepflow_tenant -> deepflow_agent_ebpf_collector`
 下的 `metrics.period_push_max_delay` 达到 199ms 时，需要关注这个
-配置项。这说明周期性 push 延迟已经触发超限标记，此时可以适当提高
-该配置项的取值。
+配置项。这说明周期性 push 延迟已经触发超限标记，此时可以适当降低
+该配置项的取值，以提高 kick 线程的调度倾向。
 
-更高的取值可以在 CPU 竞争时降低调度延迟，但也会增加对其他负载
-造成干扰的风险。
+更小的 nice 值意味着更高的调度倾向，更大的 nice 值意味着更低的
+调度倾向。取值范围为 -20 到 19。负值可能需要 CAP_SYS_NICE 或
+足够的 RLIMIT_NICE。该配置仍然可能对其他负载产生影响。
 
 #### Perf Page 数量 {#inputs.ebpf.tunning.perf_pages_count}
 

server/agent_config/README.md

@@ -5744,33 +5744,33 @@ The number of worker threads refers to how many threads participate
 in data processing in user-space. The actual maximal value is the number
 of CPU logical cores on the host.
 
-#### Kick Thread FIFO Priority {#inputs.ebpf.tunning.kick_kern_sched_priority}
+#### Kick Thread Nice Value {#inputs.ebpf.tunning.kick_kern_nice}
 
 **Tags**:
 
 <mark>agent_restart</mark>
 
 **FQCN**:
 
-`inputs.ebpf.tunning.kick_kern_sched_priority`
+`inputs.ebpf.tunning.kick_kern_nice`
 
 **Default value**:
 ```yaml
 inputs:
   ebpf:
     tunning:
-      kick_kern_sched_priority: 1
+      kick_kern_nice: 0
 ```
 
 **Schema**:
 | Key  | Value                        |
 | ---- | ---------------------------- |
 | Type | int |
-| Range | [1, 99] |
+| Range | [-20, 19] |
 
 **Description**:
 
-Controls the SCHED_FIFO priority of per-CPU kick threads.
+Controls the Linux nice value of per-CPU kick threads.
 
 These threads wake up after the periodic timer expires and issue a
 lightweight syscall to trigger kernel-side timeout checks that flush
@@ -5779,10 +5779,13 @@ batched eBPF data.
 Pay attention to this option when `metrics.period_push_max_delay`
 under `deepflow_tenant -> deepflow_agent_ebpf_collector` in Metrics
 Center reaches 199 ms. This means the periodic push delay has hit
-the exceeded marker, and the value can be increased appropriately.
+the exceeded marker, and the value can be decreased appropriately to
+give the kick threads more scheduling preference.
 
-Higher values can reduce scheduling delay under CPU contention, but
-also increase the risk of interfering with other workloads.
+Smaller nice values mean higher scheduling preference. Larger nice
+values mean lower scheduling preference. Valid values range from
+-20 to 19. A negative value may require CAP_SYS_NICE or a sufficient
+RLIMIT_NICE. This can still affect other workloads.
 
 #### Perf Pages Count {#inputs.ebpf.tunning.perf_pages_count}
 

server/agent_config/template.yaml

@@ -4257,16 +4257,16 @@ inputs:
       userspace_worker_threads: 1
       # type: int
       # name:
-      #   en: Kick Thread FIFO Priority
-      #   ch: Kick 线程 FIFO 优先级
+      #   en: Kick Thread Nice Value
+      #   ch: Kick 线程 Nice 值
       # unit:
-      # range: [1, 99]
+      # range: [-20, 19]
       # enum_options: []
       # modification: agent_restart
       # ee_feature: false
       # description:
       #   en: |-
-      #     Controls the SCHED_FIFO priority of per-CPU kick threads.
+      #     Controls the Linux nice value of per-CPU kick threads.
       #
       #     These threads wake up after the periodic timer expires and issue a
       #     lightweight syscall to trigger kernel-side timeout checks that flush
@@ -4275,24 +4275,28 @@ inputs:
       #     Pay attention to this option when `metrics.period_push_max_delay`
       #     under `deepflow_tenant -> deepflow_agent_ebpf_collector` in Metrics
       #     Center reaches 199 ms. This means the periodic push delay has hit
-      #     the exceeded marker, and the value can be increased appropriately.
+      #     the exceeded marker, and the value can be decreased appropriately to
+      #     give the kick threads more scheduling preference.
       #
-      #     Higher values can reduce scheduling delay under CPU contention, but
-      #     also increase the risk of interfering with other workloads.
+      #     Smaller nice values mean higher scheduling preference. Larger nice
+      #     values mean lower scheduling preference. Valid values range from
+      #     -20 to 19. A negative value may require CAP_SYS_NICE or a sufficient
+      #     RLIMIT_NICE. This can still affect other workloads.
       #   ch: |-
-      #     控制每个 CPU 上 kick 线程的 SCHED_FIFO 优先级。
+      #     控制每个 CPU 上 kick 线程使用的 Linux nice 值。
       #
       #     这些线程会在周期性定时器到期后唤醒，并通过轻量级 syscall
       #     触发内核侧超时检查，将批量 eBPF 数据从缓冲区中推送出来。
       #
       #     当“指标中心”中 `deepflow_tenant -> deepflow_agent_ebpf_collector`
       #     下的 `metrics.period_push_max_delay` 达到 199ms 时，需要关注这个
-      #     配置项。这说明周期性 push 延迟已经触发超限标记，此时可以适当提高
-      #     该配置项的取值。
+      #     配置项。这说明周期性 push 延迟已经触发超限标记，此时可以适当降低
+      #     该配置项的取值，以提高 kick 线程的调度倾向。
       #
-      #     更高的取值可以在 CPU 竞争时降低调度延迟，但也会增加对其他负载
-      #     造成干扰的风险。
-      kick_kern_sched_priority: 1
+      #     更小的 nice 值意味着更高的调度倾向，更大的 nice 值意味着更低的
+      #     调度倾向。取值范围为 -20 到 19。负值可能需要 CAP_SYS_NICE 或
+      #     足够的 RLIMIT_NICE。该配置仍然可能对其他负载产生影响。
+      kick_kern_nice: 0
       # type: int
       # name:
       #   en: Perf Pages Count