This commit resolves #18331. This commit resolves #18256. This commit resolves... another TODO that apparently didn't have an associated github issue. We swap out pubref's implementation of py_proto_library with our own, which more closely mirrors the interface of the internal py_proto_library, taking the descriptor file output of a proto_library rule as input. One minor change in behavior was introduced for simplicity. When a py_proto_library depends on a proto_library with a source proto file in a subdirectory of the bazel package, the import module of the resultant python library will reflect the package, *not* the full directory of the proto file, including both the bazel package and the subdirectories, as pubref did previously. This behavior also more closely mirrors google internal behavior. This commit also introduces a slightly more stringent bazel format script. Buildifier on its own will not take care of long lines, but by running yapf first, we end up with a more legible file. At the moment, there is no sanity check associated with this formatter. |
6 years ago | |
---|---|---|
.. | ||
test | Fix lint errors | 6 years ago |
BUILD | Remove dependency on pubref/rules_proto. | 6 years ago |
README.md | Remove a statement proven wrong by science | 6 years ago |
client.py | Properly import protos | 6 years ago |
prime.proto | Add basic multiprocessing-based server | 6 years ago |
server.py | Apparently no ipv6 on kokoro | 6 years ago |
README.md
Multiprocessing with gRPC Python
Multiprocessing allows application developers to sidestep the Python global
interpreter lock and achieve true concurrency on multicore systems.
Unfortunately, using multiprocessing and gRPC Python is not yet as simple as
instantiating your server with a futures.ProcessPoolExecutor
.
The library is implemented as a C extension, maintaining much of the state that
drives the system in native code. As such, upon calling
fork
, much of the
state copied into the child process is invalid, leading to hangs and crashes.
However, calling fork
without exec
in your python process is supported
before any gRPC servers have been instantiated. Application developers can
take advantage of this to parallelize their CPU-intensive operations.
Calculating Prime Numbers with Multiple Processes
This example calculates the first 10,000 prime numbers as an RPC. We instantiate
one server per subprocess, balancing requests between the servers using the
SO_REUSEPORT
socket option. Note that this
option is not available in manylinux1
distributions, which are, as of the time
of writing, the only gRPC Python wheels available on PyPI. To take advantage of this
feature, you'll need to build from source, either using bazel (as we do for
these examples) or via pip, using pip install grpcio --no-binary grpcio
.
_PROCESS_COUNT = multiprocessing.cpu_count()
On the server side, we detect the number of CPUs available on the system and spawn exactly that many child processes. If we spin up fewer, we won't be taking full advantage of the hardware resources available.
Running the Example
To run the server,
ensure bazel
is installed
and run:
bazel run //examples/python/multiprocessing:server &
Note the address at which the server is running. For example,
...
[PID 107153] Binding to '[::]:33915'
[PID 107507] Starting new server.
[PID 107508] Starting new server.
...
Note that several servers have been started, each with its own PID.
Now, start the client by running
bazel run //examples/python/multiprocessing:client -- [SERVER_ADDRESS]
For example,
bazel run //examples/python/multiprocessing:client -- [::]:33915