I have an application with several CPU intensive threads set to the SCHED_RR scheduling policy. I recently starting running this on a system with a hybrid core Intel CPU, and noticed that these threads are always getting scheduled on E cores, which is creating a performance bottleneck. After doing some experiments, it seems that all threads with a real time scheduling policy end up getting scheduled on E cores unless they are explicitly set to a P core by setting the affinity. With SCHED_NORMAL threads, I see the behavior I would expect, with threads getting dynamically scheduled across P and E cores and CPU intensive tasks generally ending up on P cores. I can reproduce this behavior with the stress-ng utility. With this command, I see the CPU stress threads are scheduled on P cores: stress-ng --cpu 4 --timeout 60s However, if I switch this same test to a real time scheduling policy (RR or FIFO), the threads are always scheduled on E cores and perform worse: stress-ng --sched rr --cpu 4 --timeout 60s What could cause this behavior? Could I be missing something in my kernel configuration? Or is it expected that the scheduler prefers E cores for real time threads? As a workaround I could just force threads on to P cores, but I'd prefer to use dynamic scheduling if possible to take advantage of both core types. Kernel version: 5.14.0-427.76.1.el9_4.x86_64+rt CPU: Intel Core i9-12900

I have scripted a Selenium automation testcase. I have generated the testng.xml file which should be executed on the linux terminal at a particular time of my need. Say I want to schdule to execute the testng.xml file on terminal at 11pm everyday.

I have a bash script needs run at a specific time and found out at is pretty much does what I need to do. But the problem is I'm not sure how can I pass command line arguments to the bash script through at. Below command is what I finally ended up after looking through some other solutions. echo "-f job.sh argument" | xargs at now + 2 minutes But this does not work. Can anyone help me with this?

I'm working on a project where I want to study the impact of process priority on system behavior. I know that tools like nice, renice, and chrt can change the priority or scheduling policy (e.g., SCHED_FIFO, SCHED_RR, etc.) from user space using system calls. However, I’m wondering: Is there any technical or practical advantage to adjusting process priority using a kernel module instead of via user-space tools like nice or chrt? Have you encountered cases where a kernel module offered more control or precision in setting scheduling parameters than user-space methods? Any insights or examples would be appreciated! **Edit** More specifically: Can setting the priority directly in the kernel (e.g., during process creation or in a module) reduce the chance of early interruptions or scheduling delays? Is there any behavioral or performance gain from assigning SCHED_FIFO 99 at the earliest possible point, compared to launching the process with chrt -f 99 ? I'm working in a forensics-related context where I want the memory acquisition process to be as undisturbed and deterministic as possible.

On Fedora 35, I create my own service to schedule a backup. I have the script in /usr/local/bin/ and service files plus timer in /lib/systemd/system/ ls -an /usr/local/bin/ prints -rwxr--r--. 1 0 0 3360 Dec 1 18:31 backup.sh ls -an /lib/systemd/system/schedule-backup_root* -rw-r--r--. 1 0 0 230 Dec 1 18:14 /lib/systemd/system/schedule-backup_root.service -rw-r--r--. 1 0 0 388 Dec 1 16:49 /lib/systemd/system/schedule-backup_root.timer but then when I start the service systemctl start schedule-backup_root.service Dec 01 18:36:13 fallen-robot systemd: Started Nightly snapshot backup job for ROOT volume. Dec 01 18:36:13 fallen-robot systemd: schedule-backup_root.service: Failed to locate executable /usr/local/bin/backup.sh: Permission denied Dec 01 18:36:13 fallen-robot systemd: schedule-backup_root.service: Failed at step EXEC spawning /usr/local/bin/backup.sh: Permission denied Dec 01 18:36:13 fallen-robot systemd: schedule-backup_root.service: Main process exited, code=exited, status=203/EXEC Dec 01 18:36:13 fallen-robot systemd: schedule-backup_root.service: Failed with result 'exit-code'. My service file looks like this: [Unit] Description=Nightly snapshot backup job for ROOT volume [Service] Type=simple ExecStart=/usr/local/bin/backup.sh -s / -b /run/media/borko/BackupTest/ -t "Fallen Robot ROOT Backup Report" [Install] WantedBy=default.target Why it cannot access the file?

I would like to execute a script every 30 min after booting into the system. I know you can use cron, but I don't plan to use this feature often therefore I'd like to try it with systemd. So far I have only found the monotonic timers which allows to execute something once (at least I think so). How would the foo.timer and foo@user.service look like in case I wanted to execute something every 30 minutes from boot/system start? **foo@user.service** [Unit] Description=run foo Wants=foo.timer [Service] User=%I Type=simple ExecStart=/bin/bash /home/user/script.sh **foo.timer** [Unit] Description=run foo [Timer] where I am stuck... ???

What is a parked thread in the context of Linux kernel? I mean a thread that is in TASK_PARKED state? How this state differs from TASK_INTERRUPTIBLE and TASK_UNINTERRUPTIBLE? From which state a thread can be woken faster? Generally, and in particular case if used for waiting: kthread_parkme / kthread_unpark instead of [s]wait_event_... / [s]wake_up_...]? I know that waitqueues support multiple waiters, but I am interested only in a single sleeper/waker pair.

I am writing a program that I would like to have the ability to schedule an action. This would work similar to the the TIME option in shutdown, where the user specifies a time and that information gets stored in a temporary file: /run/systemd/shutdown/scheduled Which contains a set of variables:

USEC=1742499354904002
WARN_WALL=1
MODE=reboot
UID=0
TTY=pts/0

At first I thought I could do something similar by having a service check for the existence of that file (with ConditionPathExists). If that file exists, read in those variables and start a second service that runs the program and has a temporary timer file, maybe like:

[Timer]
Environment=/run/systemd/customprogram/scheduled
OnCalendar=$(date -d "@${USEC}"  +"%a %Y-%m-%d %H:%M:%S") # converted

But systemd timers do not allow the Environment unit. It seems that shutdown does not use systemd timers but invokes some other method see here . Is there a simplistic, automated way to read a file to schedule a process with a variable time? I was designing this as a service because I would also be like to be able to send a signal to cancel or update the time as this program should only run a single instance at the "next" scheduled time.

On all of BSD/Linux/MacOS and Solaris, I made an observation - no matter how busy the system is, top always reports very few (usually 1-2) running processes. According to my limited understanding, a process is in "running" state if it is using CPU time, or waiting for CPU time to become available. So, here is a scenario: I use SSH to tunnel VNC, then run top on remote machine, in a Terminal emulator: - top itself is listed as a "running" process (understandable) - sshd is listed, but not "running" - Xvnc is listed, but not "running" But sshd is tunneling VNC traffic, Xvnc is what keeps me updated with screen content, how can they not be using CPU time? If they are using CPU time, then how come they are not "running"?

I have a question regarding "Realtime" support in Linux/Ubuntu: After some reasearch onthe topic, it seems that "realtime" support in Linux is twofold: On the one hand, there is the [**PREEMPT_RT**](https://en.wikipedia.org/wiki/PREEMPT_RT) patch, which brings *"real-time computing"* capabilities to the Linux kernel; on the other hand, there are the so-called **"realtime" [scheduling strategies](https://man7.org/linux/man-pages/man7/sched.7.html)** , such as SCHED_FIFO, SCHED_RR and SCHED_DEADLINE, which have been available for a long time. But how does it all come together? What happens if I use one of the *"realtime" scheduling strategies* (e.g. SCHED_DEADLINE) on a "vanilla" kernel, i.e. one that does **not** have PREEMPT_RT enabled? One would assume that this is **not** even possible. But it seems that it ***is*** possible, according to my test on a "vanilla" (non-realtime) kernel! What does it mean? Do the "realtime" scheduling strategies still work with the "non-realtime" kernel, just not "as good"? Or does it mean that the *"realtime" scheduling strategies* silently are the same as SHED_OTHER when running on a "non-realtime" kernel? Furthermore, assuming that I'm using a "realtime" kernel, i.e. one that *does* have PREEMPT_RT enabled: Will there be ***any*** difference at all, compared to a "vanilla" (non-realtime) kernel, if I do **not** explicitely start any processes with one of the "realtime" scheduling strategies? (Bonus question: How does the "niceness" play together with "realtime" scheduling? I have been looking for information, but all sources explain "niceness" *only* in the context of SHED_OTHER)

I have been trying to use nice/ionice for a while and it turns out that bfq ignores ionice parameters. So how do I prevent a low priority process from consuming all the io bandwith to the detriment of high priority processes? Even nice -n -20 high_priority_cmd;nice -n 19 low_priority_cmd;taskset -a -p 1 $(pgrep high_priority_cmd);taskset -a -p 2 $(pgrep low_priority_cmd); will result in the high_priority_cmd suffering severe latency/bandwidth issues for as long as low_priority_cmd runs. Some [documentation](https://github.com/torvalds/linux/blob/master/Documentation/block/bfq-iosched.rst#per-process-ioprio-and-weight) mentions a per process ioprio but provides no mention of how to change it. [Likely the same issue](https://unix.stackexchange.com/q/164244/529119) , with no answers that actually address the fundamental problem. There are no background services taking up io, cpu, memory, or swap. Just vlc and ffmpeg, if ffmpeg is running then vlc becomes next to unresponsive and I have to play videos at 0.5x speed to prevent skips, stalls, and garbled async(?) decoding. However if I do have lots of cpu and memory intensive services in the background then some thing as simple as md5suming a 1 GB file can stall the system to the point that not even the mouse will move on the screen. Windows OS has never had these issues with shitty incompetent IO scheduling (though to be fair my Windows system has an SSD instead of an HDD, but that is no excuse for incompetence).

Hi I was working on installing Slurm and got most things sorted out but upon launching

journalctl -fu slurmdbd

I get the following: > Jan 25 12:49:49 ... systemd: Stopped slurmdbd.service - Slurm DBD > accounting daemon. Jan 25 12:49:49 ... systemd: Started > slurmdbd.service - Slurm DBD accounting daemon. Jan 25 12:49:49 ... > (slurmdbd): slurmdbd.service: Referenced but unset > environment variable evaluates to an empty string: SLURMDBD_OPTIONS > Jan 25 12:49:49 ... slurmdbd: slurmdbd: error: Unable to open > pidfile `/run/slurmdbd.pid': Permission denied Jan 25 12:49:49 ... > slurmdbd: slurmdbd: Not running as root. Can't drop > supplementary groups Jan 25 12:49:49 ... slurmdbd: slurmdbd: > accounting_storage/as_mysql: _check_mysql_concat_is_sane: MySQL server > version is: 8.0.40-0ubuntu0.24.04.1 Jan 25 12:49:49 ... > slurmdbd: slurmdbd: error: mysql_query failed: 1193 Unknown > system variable 'wsrep_on' Jan 25 12:49:49 ... slurmdbd: > select @@wsrep_on; Jan 25 12:49:49 ... slurmdbd: slurmdbd: > error: mysql_db_get_var_str: null result from query `select > @@wsrep_on;` Jan 25 12:49:49 ... slurmdbd: slurmdbd: slurmdbd > version 23.11.4 started which I assume being the cause for sinfo not displaying correctly with the following message: > sinfo: error: Couldn't find the specified plugin name for auth/munge > looking at all files sinfo: error: cannot find auth plugin for > auth/munge sinfo: error: cannot create auth context for auth/munge > sinfo: fatal: failed to initialize auth plugin To be noted that munge seems to be working correctly, see below, and therefore I cannot pinpoint the cause of Slum not showing sinfo option other than the issue I presented before. I also attach my **slurm.conf** and **slurmdbd.conf** for clarity in case helpful; this should be the recommended installation for a single node machine. Thanks in advance! **slurm.conf**

# slurm.conf file generated by configurator.html.
# Put this file on all nodes of your cluster.
# See the slurm.conf man page for more information.
#
ClusterName=
SlurmctldHost=
MpiDefault=none
ProctrackType=proctrack/cgroup
ReturnToService=2
SlurmctldPidFile=/run/slurmctld.pid
#SlurmctldPort=6817
SlurmdPidFile=/run/slurmd.pid
#SlurmdPort=6818
SlurmdSpoolDir=/var/lib/slurm/slurmd
SlurmUser=slurm
StateSaveLocation=/var/lib/slurm/slurmctld
SwitchType=switch/none
TaskPlugin=task/cgroup
#
# TIMERS
InactiveLimit=0
KillWait=30
MinJobAge=300
SlurmctldTimeout=120
SlurmdTimeout=300
Waittime=0
# SCHEDULING
SchedulerType=sched/backfill
SelectType=select/cons_tres
SelectTypeParameters=CR_CPU_Memory
#
#ACCOUNTING STORAGE PORT
AccountingStorageType=accounting_storage/slurmdbd
AccountingStorageHost=
AccountingStoreFlags=job_comment
JobCompType=jobcomp/none
JobAcctGatherType=jobacct_gather/cgroup
JobAcctGatherFrequency=30
SlurmctldDebug=info
SlurmctldLogFile=/var/log/slurm/slurmctld.log
SlurmdDebug=info
SlurmdLogFile=/var/log/slurm/slurmd.log
#
# COMPUTE NODES
NodeName= CoresPerSocket=8 ThreadsPerCore=2 RealMemory=126397 Sockets=1
PartitionName=local Nodes=ALL Default=YES MaxTime=INFINITE State=UP

**slurmdbd.conf**

=auth/munge
DbdHost=localhost
DebugLevel=info
StorageHost=localhost
StorageLoc=slurm_acct_db
StoragePass=slurmdbpass
StorageType=accounting_storage/mysql
StorageUser=slurm
LogFile=/var/log/slurm/slurmdbd.log
PidFile=/run/slurmdbd.pid
SlurmUser=slurm

P.S. output of munge -n | unmunge

STATUS:          Success (0)
ENCODE_HOST:      (127.0.1.1)
ENCODE_TIME:     2025-02-11 09:27:00 +0100 (1739262420)
DECODE_TIME:     2025-02-11 09:27:00 +0100 (1739262420)
TTL:             300
CIPHER:          aes128 (4)
MAC:             sha256 (5)
ZIP:             none (0)
UID:              (1000)
GID:              (1000)
LENGTH:          0

I want a CPU-intensive process to have the lowest possible impact on other processes. I can use nice -19 for maximum niceness and chrt -i 0 to give the process a SCHED_IDLE priority. Which is more effective? Does it make any sense to combine the two like this? chrt -i 0 nice -19 my_command

I want to enable Energy Aware Scheduling to play around with it. How can I try it? When I run cpupower frequency-info --governors I do not see schedutil listed. I am using Debian Bookworm. Is there a way to install and enable the schedutil governor, or is there a kernel packaged with that available?

$ cpupower frequency-info --governors
analyzing CPU 0:
  available cpufreq governors: performance powersave

The full output of cpupower info, shows

analyzing CPU 0:
  driver: intel_pstate
  CPUs which run at the same hardware frequency: 0
  CPUs which need to have their frequency coordinated by software: 0
  maximum transition latency:  Cannot determine or is not supported.
  hardware limits: 800 MHz - 5.10 GHz
  available cpufreq governors: performance powersave
  current policy: frequency should be within 800 MHz and 5.10 GHz.
                  The governor "powersave" may decide which speed to use
                  within this range.
  current CPU frequency: Unable to call hardware
  current CPU frequency: 800 MHz (asserted by call to kernel)
  boost state support:
    Supported: yes
    Active: yes

I am cloning a process using the clone() glibc wrapper function. For some unrelated reasons, I need to set the CLONE_THREAD flag bit ON. It implies that > If CLONE_THREAD is set, the child is placed in the same thread group as the calling process. [...] Now, for each process (parent and child), I need to set their CPU core affinity based on some logic. However, calling sched_setaffinity(gettid(), ...) does not seem to be working in the child process. What puzzles me is that each child process is actually scheduled onto the same CPU core ID of its parent process, **even though** the child **calls sched_setaffinity after** its parent . Or better, its parent calls it before it creates the child, so that when the child calls it, it seems the call has no effect. Where's the issue?

I would like deadline to be the default IO scheduler for my system, and I don't want to lose that config when I reboot. What is the proper way of doing that? (I'm using Debian) Some hints: - have a startup script doing echo deadline >| /sys/block/sda/queue/scheduler, - use the kernel parameter elevator=deadline on GRUB startup config, - use a udev rule like SUBSYSTEM=="block", ACTION=="add|change", KERNEL=="sd[a-z]", ATTR{queue/scheduler}="deadline", - etc. What is the "preferred" solution? **EDIT:** can I have a configuration which set the iosched to deadline only for drives present at bootup, but not for subsequent hot-plugged drives (like USB keys)?

I am a user of [Linux Mint](https://en.wikipedia.org/wiki/Linux_Mint) . One feature I often wish I had in Linux is the ability to switch between light and dark modes depending on the time of the day, as in macOS and mobile devices. I have put together the following script for switching from light to dark mode:

#!/bin/bash
notify-send "Switching to dark mode"
gsettings set org.cinnamon.desktop.wm.preferences theme Mint-Y-Dark
gsettings set org.cinnamon.desktop.interface gtk-theme Mint-Y-Dark
gsettings set org.cinnamon.theme name Mint-Y-Dark

and I have another one for the opposite direction

#!/bin/bash
gsettings set org.cinnamon.desktop.wm.preferences theme Mint-Y
gsettings set org.cinnamon.desktop.interface gtk-theme Mint-Y
gsettings set org.cinnamon.theme name Mint-Y

Currently, I run these manually when I want to switch between the two themes. Most programs respect the OS-wide theme meaning this method works surprisingly well! However, there are three problems that I would like to solve with this approach: 1. Automated switching between light/dark modes depending on the time of day (as in macOS). I tried using cron and anacron but they don't work well for this purpose. When my computer is turned on after a period of being off, I would like it to realise that the time to switch has passed and perform the mode switch (as in macOS and various mobile devices); 2. I would like my terminal (GNOME Terminal, Cinnamon default) to switch from a light theme to a dark theme (and vice versa); and 3. I would like my text editor (Emacs) to load a light/dark theme. Even getting just (1) to work would be quite nice!

From my understanding a real-time process means the process will get the CPU as soon as it needs it. The kernel is responsible for this task with its internal scheduling mechanism. On the other hand, Process affinity means the process will get a dedicated CPU to itself and it won't be managed by kernel scheduler. So, if I understand correctly, it's even better than being a real-time process. It's like programming for an Arduino but only with a much faster CPU. Also, to my understanding for process affinity we need at least a dual core CPU, and we must leave at least one CPU for the OS itself. So, with the help of process affinity a program that was written for an Arduino can be ported to a Linux board like Raspberry Pi Zero 2 W (which has a quad-core CPU) and would have all the benefits of a microcontroller only with a faster CPU. Is my understanding correct?

I'm not quite sure if stackoverflow or serverfault is the forum to use for this question, but ill try here. Is there some command I can use or a file I can check in order to find out which process scheduler I'm using on my Linux system? I am not looking for the I/O scheduler, but the process scheduler, and please, do not refer to guides or howtos for what a scheduler is, what I'm simply asking is if there is a command or file I can run/check to see this. I could check the doc for my kernel but again I'm just wondering if there is a command or file i can check. I might have been a little redundant above but that's because the posts I've seen people seem to confuse process scheduler with the i/o scheduler, and they don't seem to answer the actual question, just provide links to what a scheduler is which is not what I'm after here, so apologies if the above comments sounded rude.

When I run several jobs on a head node, I like to monitor the progress using the command top. However, when I'm using PBS to run several jobs on a cluster, top will of course not show these jobs, and I have resorted to using 'qstat'. However the qstat command needs to be run repeatedly in order to continue monitoring the jobs. top updates in real-time, which means I can have the terminal window open on the side and glance at it occasionally while doing other work. Is there a way to monitor in real-time (as the top command would do) the jobs on a cluster that I've submitted using the PBS command qsub? I was surprised to see so little, after extensive searching on Google.