Perfos : Multiprocessing with shared object between Python 3.5 and 2.7 - python-2.7

Question

I can observe a HUGE time difference between python 2.7 and 3.5 running this piece of code. It seems due to my shared object _SharedProgress but i can't figure why python 3.5 (12s to run) is so much slower than 2.7 (1s to run).
Indeed if i comment progress.update(), perfos are almost identical (3.5 remains a bit slower).
Can someone explain me why? :)
Of course i would like to keep 2.7 perfo with 3.5...
from __future__ import print_function
from multiprocessing import Process
from multiprocessing.managers import BaseManager
from time import time
class _SharedProgress(object):
current = 0
def get(self):
return self.current
def update(self, new_value=1):
self.current += new_value
class _GlobalManager(BaseManager):
BaseManager.register('SharedProgress', _SharedProgress)
class WorkManager:
def __init__(self, nbWorkers, workerTask):
self.manager = _GlobalManager()
self.sharedProgress = None
self.totalProgress = nbWorkers * 100
self.pool = []
start = time()
self.manager.start()
self.sharedProgress = self.manager.SharedProgress()
inputs = [(self.sharedProgress,) for _ in range(nbWorkers)]
processToLaunch = [i for i in range(nbWorkers)]
for i in processToLaunch:
self.pool.append(Process(target=workerTask, args=inputs[i]))
while processToLaunch or any((w.is_alive() for w in self.pool)):
if processToLaunch:
self.pool[processToLaunch.pop(0)].start()
if self.sharedProgress.get() == self.totalProgress:
break
print("DONE in {}!".format(time() - start))
def __workerTask(progress):
prevPercent, current, currentPercent, total = 0, 0, 0, 10000
for i in range(total):
current += 1
currentPercent = (current * 100) / total
if currentPercent != prevPercent:
progress.update(currentPercent - prevPercent) # IF I COMMENT THIS LINE, PERFOS ARE ALMOST IDENTICAL
prevPercent = currentPercent
if __name__ == '__main__':
WorkManager(10, __workerTask)

Answer 1

The main difference comes from the division. In Python 3, dividing two integer values with / will always yield a float, in Python 2 it remained an int. You can force the python2 behavior for both versions by using //:
currentPercent = (current * 100) // total
Or the python3 behavior by initializing current = 0.. There still remains some performance gap, which might be caused by the different int types in Python 2 and 3. Python 2 used to have separate int and long types, while Python 3 only has one unified int type which covers both. If you force Python 2 to use long (current = 0L), it becomes even slower than the Python 3 version.

Answer 2

As Zulan noted,
currentPercent = (current * 100) // total
fixes the issue, but the performance issue is not directly related to integer or floating point division.
When performing a floating point division, currentPercent is always different from prevPercent, so progress bar is updated at every iteration, which is considerable redraw work, whereas with integer division, it's just updated 100 times.
This overfrequent redraw is the actual cause of the slowdowns.