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