| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| 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) |
|
|
