Trying to build a jacobian matrix using the multiprocessing library in python - how to share a matrix variable across multiple processes?

I was trying to construct the jacobian matrix in python using central differences. I want to use multiple cores that I have access to to build this matrix. I tried to use the Process library. I wasn't sure if this or the pool library would let me utilize more cores to complete this task. Suggestions on what would be better would be greatly appreciated!

Anyhow, my thought process was that I would define an empty NxN matrix, and then have the process fill in every column of this matrix using multiprocessing. It looks to me the output is the zero matrix (what I instatiated it to be orginally), but when I look at every process execution, the column of the matrix is correct.

jacobian after process 1
[[2. 0.]
 [4. 0.]]
jacobian after process 2
[[0. 1.]
 [0. 4.]]
final jacobian
[[0. 0.]
 [0. 0.]]


p=Process(target=jac_part, args=(i,x,h,Jac))

It seems to me that the "Jac" I am passing is not being treated as an object that is being edited. Anyone have any ideas how I can maintain the state at the different process work on the matrix? Below is a bare bones code - any suggestions would greatly be appreciated.

Thank you

import numpy as np
import multiprocessing
from multiprocessing import Process

def Jacobian(f, h = 1e-6):
	
	return lambda x: jacobian_pool(f, x, h = h)

def jacobian_pool(f, x, h):
	#pool = Pool(multiprocessing.cpu_count()-1)
	Jac = np.zeros((len(x),len(x)))
	processes=[]
	for i in range(len(x)):
		p=Process(target=jac_part, args=(i,x,h,Jac))
		processes.append(p)

	for p in processes:
		p.start()
		p.join()
	
	return Jac


def jac_part(i,x,h,Jac):
    x_plus = x.copy()
    x_minus = x.copy()
    x_plus[i] += h
    x_minus[i] -= h
    f_plus = f(x_plus)
    f_minus = f(x_minus)
    Jac[:, i] = (f_plus - f_minus) / (2 * h)
    print(Jac)



def f(x):
		return np.array([x[0] ** 2 + x[1], 2 * x[0] ** 2 + x[1] ** 2])
x = np.array([1., 2.])
jf = Jacobian(f)
print(jf(x))

I was succesfull using pool. I use pool to calculate each column of the matrix, then in post-processing filled those columns into the actual matrix I am returning. Thanks for the suggestions all.

import numpy as np
import multiprocessing
from multiprocessing import Process
from multiprocessing import Pool

def Jacobian(f, h = 1e-6):
	
	return lambda x: jacobian_pool(f, x, h = h)

def jacobian_pool(f, x, h):
    pool = Pool(multiprocessing.cpu_count()-1)
    Jac = np.zeros((len(x),len(x)))
    async_results = [pool.apply_async(jac_part, args=(i, x, h)) for i in range(len(x))]
    results = [ar.get() for ar in async_results]
    for r in results:
        jac_pie = r[0]
        i= r[1]
        Jac[:,i] = jac_pie
    return Jac
	# processes=[]
	# for i in range(len(x)):
	# 	p=Process(target=jac_part, args=(i,x,h,Jac))
	# 	processes.append(p)

	# for p in processes:
	# 	p.start()
	# 	p.join()
	
	# return Jac


def jac_part(i,x,h):
    x_plus = x.copy()
    x_minus = x.copy()
    x_plus[i] += h
    x_minus[i] -= h
    f_plus = f(x_plus)
    f_minus = f(x_minus)
    # Jac[:, i] = (f_plus - f_minus) / (2 * h)
    return ((f_plus - f_minus) / (2 * h),i)
    



def f(x):
		return np.array([x[0] ** 2 + x[1], 2 * x[0] ** 2 + x[1] ** 2])
x = np.array([1., 2.])
jf = Jacobian(f)
print(jf(x))