Last active
May 8, 2024 20:58
-
-
Save EdwinChan/3c13d3a746bb3ec5082f to your computer and use it in GitHub Desktop.
Trick for using multiprocessing with nested functions and lambda expressions
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
import concurrent.futures | |
import multiprocessing | |
import sys | |
import uuid | |
def globalize(func): | |
def result(*args, **kwargs): | |
return func(*args, **kwargs) | |
result.__name__ = result.__qualname__ = uuid.uuid4().hex | |
setattr(sys.modules[result.__module__], result.__name__, result) | |
return result | |
def main(): | |
@globalize | |
def func1(x): | |
return x | |
func2 = globalize(lambda x: x) | |
with multiprocessing.Pool() as pool: | |
print(pool.map(func1, range(10))) | |
print(pool.map(func2, range(10))) | |
with concurrent.futures.ThreadPoolExecutor() as executor: | |
print(list(executor.map(func1, range(10)))) | |
print(list(executor.map(func2, range(10)))) | |
if __name__ == '__main__': | |
main() |
@pk1234dva As far as I understand it, multiprocessing
pickles the function name so that the worker processes know where to start. The trick here simply automates the creation of wrappers that can be pickled. Nothing else is pickled, neither in the global scope nor in the local scope, so the module must still be available in some form for the program to work. Whether the worker processes inherit the module in memory as a result of a fork or import the module anew is mostly an implementation detail.
@EdwinChan Thank you.
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
@EdwinChan Thanks for sharing this. Sorry to bother but could you clarify a bit more why exactly this works? I'm not sure I get this right - are objects at the global level still pickled and unpickled, or does this solution rely on the fact that the process gets forked, and so it's directly accessible as a global object even in the forked process? (in unix systems)
It seems that as far as pickling functions goes, it's just the name that gets pickled, and so making the function global really just allows for that to happen - to pickle/unpickle the name. So it looks like this solution does heavily rely on the fact that, the function will exist in memory of the replicated process - due to either forking, or due to the fact that the function will deterministically recreated (windows). Do I get that right?