Sharing a large numpy array across python multiprocessing map

I have a script which is parallelized but requires reading from a large numpy array whose size might vary between different cases(can be 100GB+). The array is to be read-only. I have a class object(say A) which is being parallelized and is being called from inside a function of a different class(say B). I started of by setting the array as a member of class B but this meant that for every thread being created, the object was being pickled and then loaded which caused the program to be very slow(I worked around this to divide the array into small batches and that helped it to be much faster). I then tried to make the array a global variable but this is also slower than expected. Is there a better approach to this problem to get the fastest solution?

The following (unrealistic) example adds the elements of a read-only numpy array by using multiprocessing to individually add each row and then performing a final summation over the partial sums.

A shared memory array is created from the numpy arrays buffer. A "process pool initializer" is then used to initialize each pool process with a numpy array based on the shared array.

import numpy as np
import multiprocessing
import ctypes

def init_process(shared_array, shape):
    global arr

    arr = shared_array_to_np_array(shared_array, shape)

def worker(row_number):
    return np.sum(arr[row_number])

def np_array_to_shared_array(arr, ctype):
    shared_array = multiprocessing.RawArray(ctype, arr.size)
    temp = np.frombuffer(shared_array, dtype=arr.dtype)
    temp[:] = arr.flatten(order='C')
    return shared_array

def shared_array_to_np_array(shared_array, shape):
    return np.ctypeslib.as_array(shared_array).reshape(shape)

def main():
    """
    Sum all elements by summing each row and then adding together
    the partial sums.
    """

    arr = np.array([[1, 2, 3, 4],
                    [5, 6, 7, 8,],
                    [9, 10, 11, 12]], dtype=np.int32)
    shape = arr.shape
    n_rows = shape[0]
    dtype = arr.dtype
    shared_array = np_array_to_shared_array(arr, ctypes.c_int32)
    arr = shared_array_to_np_array(shared_array, shape)
    with multiprocessing.Pool(n_rows, initializer=init_process, initargs=(shared_array, shape)) as pool:
        print(sum(pool.map(worker, range(n_rows))))

if __name__ == '__main__':
    main()

Prints:

78