programs that can't run parallely

I am building a python program to initiates the same program (benchmark_program in this example) with different parameters and then examine the results.

To improve efficiency I invoke several subprocess from multiprocessing.Pool to run each command in parallel. Then the weird thing is: however core number (number of parallel subprocess) increase (still below the physical core number and all cores are available), the total test time remians constant and from htop I found that everytime the script executes, only 1 core is actually engaged (IO is not busy either).

At first I thought it's a python problem so I wrote a simple program compute_primes to do some heavy computation on 1 single cores, and parallelizing does improve performance.

So I guess there is something in benchmark_program, perhaps some libraries, that can be invoked/called by only 1 cpu at a time. Now my question is: what makes a program that can't be run parallely? Is it some shared libraries or dependences?

the test script:

from multiprocessing import Pool
import subprocess
import time


def invoke_subprocess(arg):
    #command = "benchmark_program {}".format(arg)
    #command = "compute_primes {}".format(arg)

    command = "sleep 0.5"

    return subprocess.run(command,
                          shell=True,
                          check=True,
                          stdout=subprocess.DEVNULL,
                          stderr=subprocess.STDOUT).returncode


if __name__ == '__main__':
    for num_core in [2, 4, 8, 16]:
        start = time.time()
        with Pool(num_core) as p:
            collected_result = p.map(invoke_subprocess, range(16))
        print("core-{} took {:.2f} second".format(num_core,
                                                  time.time() - start))

This is basically the parallel script. You get the original program when commenting command = "sleep 0.5" and uncomment #command = "benchmark_program {}".format(arg)

> Now my question is: what makes a program that can't be run parallely?

Any number of things:

• the program can bind itself to a single CPU using sched_setaffinity
• the program can use flock to lock a file and prevent other executions of itself
• the program can create a semaphore to achieve the same
• the program can create a "lock file", and the second execution could wait until that file is removed. The file could also be a unix domain socket, or a named pipe.

There are probably tens of different mechanisms which could be used to prevent concurrent execution. You can use strace to figure out what the program actually does, and go from there.