def __call__(self):
# List in which we store all ongoing communications
pending_comms = []
# Vector of the used mailboxes
mboxes = [
Mailbox.by_name("receiver-{:d}".format(i))
for i in range(0, self.receivers_count)
]
# Start dispatching all messages to receivers, in a round robin fashion
for i in range(0, self.messages_count):
content = "Message {:d}".format(i)
mbox = mboxes[i % self.receivers_count]
this_actor.info("Send '{:s}' to '{:s}'".format(content, str(mbox)))
# Create a communication representing the ongoing communication, and store it in pending_comms
comm = mbox.put_async(content, self.msg_size)
pending_comms.append(comm)
# Start sending messages to let the workers know that they should stop
for i in range(0, self.receivers_count):
mbox = mboxes[i]
this_actor.info("Send 'finalize' to '{:s}'".format(str(mbox)))
comm = mbox.put_async("finalize", 0)
pending_comms.append(comm)
this_actor.info("Done dispatching all messages")
# Now that all message exchanges were initiated, wait for their completion in one single call
Comm.wait_all(pending_comms)
this_actor.info("Goodbye now!")
def __call__(self):
pending_comms = []
mbox = Mailbox.by_name("receiver")
for i in range(self.msg_count):
msg = "Message " + str(i)
size = self.msg_size * (i + 1)
this_actor.info("Send '%s' to '%s, msg size: %d'" %
(msg, mbox.name, size))
comm = mbox.put_async(msg, size)
pending_comms.append(comm)
this_actor.info("Done dispatching all messages")
# Now that all message exchanges were initiated, wait for their completion in one single call
Comm.wait_all(pending_comms)
this_actor.info("Goodbye now!")
def __call__(self):
mbox = Mailbox.by_name("receiver")
pending_msgs = []
pending_comms = []
this_actor.info("Wait for %d messages asynchronously" % self.msg_count)
for _ in range(self.msg_count):
comm, data = mbox.get_async()
pending_comms.append(comm)
pending_msgs.append(data)
while len(pending_comms) > 0:
index = Comm.wait_any(pending_comms)
msg = pending_msgs[index].get()
this_actor.info("I got '%s'." % msg)
del pending_comms[index]
del pending_msgs[index]
def __call__(self):
# List in which we store all ongoing communications
pending_comms = []
# Vector of the used mailboxes
mboxes = [
Mailbox.by_name("receiver-{:d}".format(i))
for i in range(0, self.receivers_count)
]
# Start dispatching all messages to receivers, in a round robin fashion
for i in range(0, self.messages_count):
content = "Message {:d}".format(i)
mbox = mboxes[i % self.receivers_count]
this_actor.info("Send '{:s}' to '{:s}'".format(content, str(mbox)))
# Create a communication representing the ongoing communication, and store it in pending_comms
comm = mbox.put_async(content, self.msg_size)
pending_comms.append(comm)
# Start sending messages to let the workers know that they should stop
for i in range(0, self.receivers_count):
mbox = mboxes[i]
this_actor.info("Send 'finalize' to '{:s}'".format(str(mbox)))
comm = mbox.put_async("finalize", 0)
pending_comms.append(comm)
this_actor.info("Done dispatching all messages")
# Now that all message exchanges were initiated, wait for their completion, in order of completion.
#
# This loop waits for first terminating message with wait_any() and remove it with del, until all comms are
# terminated.
# Even in this simple example, the pending comms do not terminate in the exact same order of creation.
while pending_comms:
changed_pos = Comm.wait_any(pending_comms)
del pending_comms[changed_pos]
if (changed_pos != 0):
this_actor.info(
"Remove the {:d}th pending comm: it terminated earlier than another comm that was initiated first."
.format(changed_pos))
this_actor.info("Goodbye now!")