Linux command execution rate limiting

Question

I have a Linux command that can be called by another application multiple times (in quick succession) with different parameters. The problem is, if the command gets executed in too quick of succession, the function that it performs will not work properly.

What I’m looking for is some simple way to ensure that each call to the command will be properly delayed/spaced (by a couple milliseconds) from each other.

Order of execution does not matter in this case and I have no control over how the application makes the calls.

Edit: The command being called is used to transmit an RF signal on a Raspberry Pi. As such, the command execution must be exclusive (no concurrency) with an additional delay between executions to prevent the receivers from misreading the signals.

Does that work when the calls to the command are in parallel? — KYDronePilot, Dec 20 '19 at 13:26
Would this help you ? https://stackoverflow.com/a/185473/12396017 — Maxim Sagaydachny, Dec 20 '19 at 14:07
Not precisely, since I want it to block until other calls complete, but it looks like that would be a quick fix. — KYDronePilot, Dec 20 '19 at 15:26
Do you need to implement this only at your end, or can you make changes to the caller? — Gem Taylor, Dec 20 '19 at 17:14
Can you provide few more details about the process (or show simplified version). There are few options to limit concurrent execution (vs allowing single execution using the flock). — dash-o, Dec 21 '19 at 08:45
I added more info to the question. In reality, what I needed was single execution, so flock was the right fix. I will keep your answer in mind, however, if I ever need more than single execution in a similar problem. — KYDronePilot, Dec 21 '19 at 14:46

score 2 · Accepted Answer · answered Dec 20 '19 at 21:16

2

For anyone with the same problem, this worked for me: https://unix.stackexchange.com/questions/408934/how-to-serialize-command-execution-on-linux

CMD="<some command> && sleep <some delay in seconds>"

flock /tmp/some_lockfile $CMD

answered Dec 20 '19 at 21:16

KYDronePilot

527
3
12

score 1 · Answer 2 · answered Dec 21 '19 at 08:55

For a simple concurrency control, which will limit concurrent execution to instances, consider the following while loop (modify as needed).

Note that the script must be invoked as /path/to/script.sh so that it will find other instances. Starting with 'bash /path/to/script.sh' will require changes!

#! /bin/bash

   # Process identifier.
echo "START $$"
ME=${0##*/}
   # Max number of instances
N=5
   # Sleep while there are more than N instances.
while [[ "$(pgrep -c -x $ME)" -gt "$N" ]] ; do echo Waiting ... ; sleep 1 ; done

   # Execute the job
sleep "$@"
echo "Done $$"

Linux command execution rate limiting

2 Answers2