python - Why is multiprocessing slower in my Pool function than my non Pool function?

Question

I wrote the following multitprocessing application and i have it's non Pool counterpart. The Pool version is awfully slow, but i can't figure out why. I tried some debugging techniques with time.time() which i left in the code. From what i can see, it shouldn't be slow, but is. Is anyone familiar with multiprocessing to know what i'm doing incorrectly here?

(You can replace the gmpy2 calls with math. if you have python 3.8 and not gmpy2)

import time
import gmpy2

def get_mod_congruence(root, N, withstats=False):
  r = root - N 
  if withstats==True:
    print(f"{root} ≡ {r} mod {N}")
  return r

def factorise(N):
  N = gmpy2.mpz(N)
  if N%2 == 0:
    return 2
  Nsqrt = gmpy2.isqrt(N)
  x=gmpy2.mpz(1)
  while True and x < Nsqrt:
    Nmodcongruence = get_mod_congruence((Nsqrt+x)**2, N)
    Ngcd = gmpy2.gcd(Nsqrt+x-gmpy2.isqrt(Nmodcongruence), N)
    if Ngcd != 1:
      break
    x+=1
  return Ngcd
 
def Ngcd(arglist):
   Nsqrt = arglist[0]
   x = arglist[1]
   Nmodcongruence = arglist[2]
   N = arglist[3]
   return gmpy2.gcd(Nsqrt+x-Nmodcongruence, N)

def factorise(N):
  N = gmpy2.mpz(N)
  if N%2 == 0:
    return 2
  Nsqrt = gmpy2.isqrt(N)
  x=gmpy2.mpz(1)
  while True and x < Nsqrt:
    Nmodcongruence = get_mod_congruence((Nsqrt+x)**2, N)
    Ngcd = gmpy2.gcd(Nsqrt+x-gmpy2.isqrt(Nmodcongruence), N)
    if Ngcd != 1:
      break
    x+=1
  return Ngcd
  
  
def factorisethreaded(N):

  from multiprocessing import Pool
  
  cpus = 4
  N = gmpy2.mpz(N)
  if N%2 == 0:
    return 2
  Nsqrt = gmpy2.isqrt(N)
  x=1 #gmpy2.mpz(1)
  while True and x < Nsqrt:
    start = time.time()
    arglist=[]
    for xx in range(x, cpus+x):
       Nmodcongruence = get_mod_congruence((Nsqrt+xx)**2, N)
       arglist.append([Nsqrt,xx,gmpy2.isqrt(Nmodcongruence), N])
       #print(xx, 1)
    end = time.time()
    #print(end-start)
    
    start = time.time()
    with Pool(cpus) as p:
       Ngcdresults=p.map(Ngcd, arglist)
    end = time.time()
    #print(end-start, len(arglist)) 
    
    start = time.time()
    Ngcdcheck = max(Ngcdresults)
    if Ngcdcheck > 1:
      return Ngcdresults[Ngcdresults.index(Ngcdcheck)]
    x+=cpus
    end = time.time()
    #print(end-start, x)

  return 1  
  
factorise(1009*7013)
# 1009
factorisethreaded(1009*7013)
# 1009

question from:https://stackoverflow.com/questions/65647459/why-is-multiprocessing-slower-in-my-pool-function-than-my-non-pool-function

Answer 1

Waitting for answers