|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
import queue |
|
import collections |
|
import threading |
|
|
|
__all__ = ['FutureResult', 'SlavePipe', 'SyncMaster'] |
|
|
|
|
|
class FutureResult(object): |
|
"""A thread-safe future implementation. Used only as one-to-one pipe.""" |
|
|
|
def __init__(self): |
|
self._result = None |
|
self._lock = threading.Lock() |
|
self._cond = threading.Condition(self._lock) |
|
|
|
def put(self, result): |
|
with self._lock: |
|
assert self._result is None, 'Previous result has\'t been fetched.' |
|
self._result = result |
|
self._cond.notify() |
|
|
|
def get(self): |
|
with self._lock: |
|
if self._result is None: |
|
self._cond.wait() |
|
|
|
res = self._result |
|
self._result = None |
|
return res |
|
|
|
|
|
_MasterRegistry = collections.namedtuple('MasterRegistry', ['result']) |
|
_SlavePipeBase = collections.namedtuple('_SlavePipeBase', ['identifier', 'queue', 'result']) |
|
|
|
|
|
class SlavePipe(_SlavePipeBase): |
|
"""Pipe for master-slave communication.""" |
|
|
|
def run_slave(self, msg): |
|
self.queue.put((self.identifier, msg)) |
|
ret = self.result.get() |
|
self.queue.put(True) |
|
return ret |
|
|
|
|
|
class SyncMaster(object): |
|
"""An abstract `SyncMaster` object. |
|
|
|
- During the replication, as the data parallel will trigger an callback of each module, all slave devices should |
|
call `register(id)` and obtain an `SlavePipe` to communicate with the master. |
|
- During the forward pass, master device invokes `run_master`, all messages from slave devices will be collected, |
|
and passed to a registered callback. |
|
- After receiving the messages, the master device should gather the information and determine to message passed |
|
back to each slave devices. |
|
""" |
|
|
|
def __init__(self, master_callback): |
|
""" |
|
|
|
Args: |
|
master_callback: a callback to be invoked after having collected messages from slave devices. |
|
""" |
|
self._master_callback = master_callback |
|
self._queue = queue.Queue() |
|
self._registry = collections.OrderedDict() |
|
self._activated = False |
|
|
|
def __getstate__(self): |
|
return {'master_callback': self._master_callback} |
|
|
|
def __setstate__(self, state): |
|
self.__init__(state['master_callback']) |
|
|
|
def register_slave(self, identifier): |
|
""" |
|
Register an slave device. |
|
|
|
Args: |
|
identifier: an identifier, usually is the device id. |
|
|
|
Returns: a `SlavePipe` object which can be used to communicate with the master device. |
|
|
|
""" |
|
if self._activated: |
|
assert self._queue.empty(), 'Queue is not clean before next initialization.' |
|
self._activated = False |
|
self._registry.clear() |
|
future = FutureResult() |
|
self._registry[identifier] = _MasterRegistry(future) |
|
return SlavePipe(identifier, self._queue, future) |
|
|
|
def run_master(self, master_msg): |
|
""" |
|
Main entry for the master device in each forward pass. |
|
The messages were first collected from each devices (including the master device), and then |
|
an callback will be invoked to compute the message to be sent back to each devices |
|
(including the master device). |
|
|
|
Args: |
|
master_msg: the message that the master want to send to itself. This will be placed as the first |
|
message when calling `master_callback`. For detailed usage, see `_SynchronizedBatchNorm` for an example. |
|
|
|
Returns: the message to be sent back to the master device. |
|
|
|
""" |
|
self._activated = True |
|
|
|
intermediates = [(0, master_msg)] |
|
for i in range(self.nr_slaves): |
|
intermediates.append(self._queue.get()) |
|
|
|
results = self._master_callback(intermediates) |
|
assert results[0][0] == 0, 'The first result should belongs to the master.' |
|
|
|
for i, res in results: |
|
if i == 0: |
|
continue |
|
self._registry[i].result.put(res) |
|
|
|
for i in range(self.nr_slaves): |
|
assert self._queue.get() is True |
|
|
|
return results[0][1] |
|
|
|
@property |
|
def nr_slaves(self): |
|
return len(self._registry) |
|
|
