def run_crypten_party_jail(self, msg: CryptenInitJail): # pragma: no cover
"""Run crypten party according to the information received.
Args:
message (CryptenInitJail): should contain the rank, world_size,
master_addr and master_port.
Returns:
An ObjectMessage containing the return value of the crypten function computed.
"""
rank_to_worker_id, world_size, master_addr, master_port = msg.crypten_context
cid = syft.ID_PROVIDER.pop()
syft_crypten.RANK_TO_WORKER_ID[cid] = rank_to_worker_id
ser_func = msg.jail_runner
onnx_model = msg.model
crypten_model = None if onnx_model is None else utils.onnx_to_crypten(
onnx_model)
jail_runner = JailRunner.detail(ser_func, model=crypten_model)
rank = self._current_rank(rank_to_worker_id)
assert rank is not None
return_value = run_party(cid, jail_runner, rank, world_size,
master_addr, master_port, (), {})
# remove rank to id transaltion dict
del syft_crypten.RANK_TO_WORKER_ID[cid]
return ObjectMessage(return_value)
def test_send_msg():
"""Tests sending a message with a specific ID
This is a simple test to ensure that the BaseWorker interface
can properly send/receive a message containing a tensor.
"""
# get pointer to local worker
me = sy.torch.hook.local_worker
# pending time to simulate lantency (optional)
me.message_pending_time = 0.1
# create a new worker (to send the object to)
worker_id = sy.ID_PROVIDER.pop()
bob = VirtualWorker(sy.torch.hook, id=f"bob{worker_id}")
# initialize the object and save it's id
obj = torch.Tensor([100, 100])
obj_id = obj.id
# Send data to bob
start_time = time()
me.send_msg(ObjectMessage(obj), bob)
elapsed_time = time() - start_time
me.message_pending_time = 0
# ensure that object is now on bob's machine
assert obj_id in bob.object_store._objects
# ensure that object was sent 0.1 secs later
assert elapsed_time > 0.1
def send_obj(self, obj: object, location: "BaseWorker"):
"""Send a torch object to a worker.
Args:
obj: A torch Tensor or Variable object to be sent.
location: A BaseWorker instance indicating the worker which should
receive the object.
"""
return self.send_msg(ObjectMessage(obj), location)
def run_crypten_party_plan(
self, msg: CryptenInitPlan) -> ObjectMessage: # pragma: no cover
"""Run crypten party according to the information received.
Args:
msg (CryptenInitPlan): should contain the rank_to_worker_id, world_size,
master_addr and master_port.
Returns:
An ObjectMessage containing the return value of the crypten function computed.
"""
rank_to_worker_id, world_size, master_addr, master_port = msg.crypten_context
cid = syft.ID_PROVIDER.pop()
syft_crypten.RANK_TO_WORKER_ID[cid] = rank_to_worker_id
onnx_model = msg.model
crypten_model = None if onnx_model is None else utils.onnx_to_crypten(
onnx_model)
# TODO Change this, we need a way to handle multiple plan definitions
plans = self.worker.search("crypten_plan")
if len(plans) != 1:
raise ValueError(
f"Error: {len(plans)} plans found. There should be only 1.")
plan = plans[0].get()
rank = self._current_rank(rank_to_worker_id)
if rank is None:
raise ValueError("Current rank can't be None")
if crypten_model:
args = (crypten_model, )
else:
args = ()
return_value = run_party(cid, plan, rank, world_size, master_addr,
master_port, args, {})
# remove rank to id transaltion dict
del syft_crypten.RANK_TO_WORKER_ID[cid]
# Delete the plan at the end of the computation
self.worker.de_register_obj(plan)
return ObjectMessage(return_value)
def test_recv_msg():
"""Tests the recv_msg command with 2 tests
The first test uses recv_msg to send an object to alice.
The second test uses recv_msg to request the object
previously sent to alice."""
# TEST 1: send tensor to alice
# create a worker to send data to
worker_id = sy.ID_PROVIDER.pop()
alice = VirtualWorker(sy.torch.hook, id=f"alice{worker_id}")
# create object to send
obj = torch.Tensor([100, 100])
# create/serialize message
message = ObjectMessage(obj)
bin_msg = serde.serialize(message)
# have alice receive message
alice.recv_msg(bin_msg)
# ensure that object is now in alice's registry
assert obj.id in alice.object_store._objects
# Test 2: get tensor back from alice
# Create message: Get tensor from alice
message = ObjectRequestMessage(obj.id, None, "")
# serialize message
bin_msg = serde.serialize(message)
# call receive message on alice
resp = alice.recv_msg(bin_msg)
obj_2 = sy.serde.deserialize(resp)
# assert that response is correct type
assert type(resp) == bytes
# ensure that the object we receive is correct
assert obj_2.id == obj.id
def test_send_msg():
"""Tests sending a message with a specific ID
This is a simple test to ensure that the BaseWorker interface
can properly send/receive a message containing a tensor.
"""
# get pointer to local worker
me = sy.torch.hook.local_worker
# create a new worker (to send the object to)
worker_id = sy.ID_PROVIDER.pop()
bob = VirtualWorker(sy.torch.hook, id=f"bob{worker_id}")
# initialize the object and save it's id
obj = torch.Tensor([100, 100])
obj_id = obj.id
# Send data to bob
me.send_msg(ObjectMessage(obj), bob)
# ensure that object is now on bob's machine
assert obj_id in bob._objects