Recommended Practice¶
This tutorial shows how to use
@parl.remote_class
to implement parallel computation with multi-threads.Python has poor performance in multi-threading because of the GIL , and we always find that multi-thread programming in Python cannot bring any benefits of the running speed, unlike other program languages such as
C++
and JAVA
.Here we reveal the performance of Python threads. At first, let’s run the following code:
class A(object):
def run(self):
ans = 0
for i in range(100000000):
ans += i
a = A()
for _ in range(5):
a.run()
This code takes 17.46 seconds to finish counting from 1 to 1e8 for five times.
Now let’s implement a thread-based code using the Python library,
threading
, as shown below.import threading
class A(object):
def run(self):
ans = 0
for i in range(100000000):
ans += i
threads = []
for _ in range(5):
a = A()
th = threading.Thread(target=a.run)
th.start()
threads.append(th)
for th in threads:
th.join()
It takes 41.35 seconds, much slower than previous code that finish counting serially. As the performance is limited by the GIL, there is only a single CPU running the task, and the CPU has to spend additional time on switching tasks between different threads.
Finally, let’s try to use PARL:
import threading
import parl
@parl.remote_class
class A(object):
def run(self):
ans = 0
for i in range(100000000):
ans += i
threads = []
parl.connect("localhost:6006")
for _ in range(5):
a = A()
th = threading.Thread(target=a.run)
th.start()
threads.append(th)
for th in threads:
th.join()
Only 3.74 seconds are needed !!! As you can see from the code above, it is the
@parl.remote_class
that makes the change happen. By simply adding this decorator, we achieved real multi-thread computation.In our next tutorial, we are going to show how to implement parallel computation without multithreading.