I used a 2 workers pool to split a sum in a function with Python multiprocessing but the timing doesn't speed up, is there something I'm missing?

I modified your fun1:

import multiprocessing
import time
import random

def fun1( x ):
    y = 0
    for i in range( len( x ) ):
        
        if 0.3 < x[i] < 0.5:
            y = y + x[i]
            
        
        elif x[i] >= 0.5:
            
            y += x[i]**2
            
        else:
            
            y += 1
        
    return( y )

def fun2( x ):
    p = multiprocessing.Pool( 2 )
    y1, y2 = p.map( fun1, [ x[ : len( x ) // 2 ], x[ len( x ) // 2 : ] ] )
    y = y1 + y2
    return( y )

x = [ random.random() for i in range( 10 ** 6 ) ]

st = time.time()
ans = fun1( x )
et = time.time()
print( f"time = {et - st}, answer = {ans}." )

st = time.time()
ans = fun2( x )
et = time.time()
print( f"time = {et - st}, answer = {ans}." )

x = [ random.random() for i in range( 10 ** 7 ) ]

st = time.time()
ans = fun1( x )
et = time.time()
print( f"time = {et - st}, answer = {ans}." )

st = time.time()
ans = fun2( x )
et = time.time()
print( f"time = {et - st}, answer = {ans}." )

output, seems reproducible to me (I've a small CPU):

time = 0.5544326305389404, answer = 671883.5322289083.
time = 0.5338046550750732, answer = 671883.5322288958.
time = 4.955313205718994, answer = 6715366.44807873.
time = 3.6769814491271973, answer = 6715366.448078716.

#anoter try:

time = 0.5013079643249512, answer = 671620.2326088196.
time = 0.39491748809814453, answer = 671620.2326088334.
time = 4.901585578918457, answer = 6717295.294786744.
time = 3.776726484298706, answer = 6717295.294786792.

#next:

time = 0.4863710403442383, answer = 671647.0603678812.
time = 0.6218230724334717, answer = 671647.0603678576.
time = 5.027068376541138, answer = 6716671.888051354.
time = 3.752805471420288, answer = 6716671.888051517.

I think it is related to Understanding time complexity with Python examples

but I could be wrong. I am trying to learn too.

Addendum

As per a previous good answer that was deleted:

using Multiprocessing.Pool().map as from Multiprocessing in Python - all about pickling

Multiprocessing in Python is flexible. You can either define Processes and orchestrate them as you wishes, or use one of excellent methods herding Pool of processes. By default Pool assumes number of processes to be equal to number of CPU cores, but you can change it by passing processes parameter. Main methods included in Pool are apply and map, which let you run process with arbitrary arguments or execute parallel map, respectively. There are also asynchronous versions of these, i.e. apply_async and map_async.Simple, right? Yes, this is all what's needed. Now, go and use multiprocessing!

Actually, before you leave to follow your dreams there's a small caveat to this. When executing processes Python first pickles these methods. This create a bottleneck as only objects that are pickle will be passed to processes. Moreover, Pool doesn't allow to parallelize objects that refer to the instance of pool which runs them.

Yes, this is all because of Pickle. What can you do with it? In a sense, not much, as it's the default battery-included solution. On the other, pickle is generally slow

Deleted answer:

You are copying considerably large amount of data (>90MB), so fun2 is consuming a lot of time for data copying (serialize/deserilaize, inter-process communication),

>>> import pickle
>>> import random
>>> datea = [random.random() for i in range(10 ** 7)]
>>> len(pickle.dumps(data)
90032371

Instead of passing large data directly, you can store your data in multiple files, and distribuite file names to workers.

You may want to use parallel computing framework (such as Polars, Dask and Ray), depending on your workload.

When multiprocessing, your list has to be serialised. This is achieved using pickle. When the length of your list is 10**7 the in-memory size of the list is 89,095,160. The serialised object is slightly larger at 90,032,371. That 90MB object is written to disk (in some temporary location) then consumed prior to execution of your function. That is a relatively slow process.

You can improve matters slightly by not serialising to disk. Instead you can use shared memory although that still won't be as fast as the linear execution - i.e., when fun1() is called directly

Here's a variation of your code that demonstrates the 3 techniques, prints the object sizes and outputs the various timings:

import multiprocessing
import time
import random
from multiprocessing.shared_memory import SharedMemory
import pickle
import sys


def fun1(x):
    return sum(x)


def fun2(x):
    with multiprocessing.Pool() as p:
        data = [x[: len(x) // 2], x[len(x) // 2 :]]
        return sum(p.map(fun1, data))


def fun3(name):
    shm = SharedMemory(name)
    try:
        x = pickle.loads(shm.buf)
        return fun1(x)
    finally:
        shm.close()


if __name__ == "__main__":
    x = [random.random() for i in range(10**7)]
    size = sys.getsizeof(x)
    print(f"In-memory {size=:,}")
    try:
        smb = pickle.dumps(x)
        size = len(smb)
        print(f"Pickled object {size=:,}")
        shm = SharedMemory(create=True, size=size)
        shm.buf[:size] = smb
        for func in fun1, fun2:
            st = time.perf_counter()
            ans = func(x)
            et = time.perf_counter()
            print(func.__name__, f"time = {et - st}, answer = {ans}.")
        st = time.perf_counter()
        ans = fun3(shm.name)
        et = time.perf_counter()
        print(fun3.__name__, f"time = {et - st}, answer = {ans}.")
    finally:
        shm.close()
        shm.unlink()

Output:

In-memory size=89,095,160
Pickled object size=90,032,371
fun1 time = 0.21793299994897097, answer = 4999444.726535229.
fun2 time = 0.6652624170528725, answer = 4999444.726535082.
fun3 time = 0.4321752089308575, answer = 4999444.726535229.

Note:

Your results may differ due to platform and Python version differences.

Here the platform is:

Python 3.13.0
MacOS 15.1.1
Apple M2