def test_remove(self):
# Set up two nodes and run a simulation in which items
# are randomly added at specific time intervals
sim_reset()
alice = QuantumNode("Alice", 1)
bob = QuantumNode("Bob", 2)
conn = ClassicalFibreConnection(alice, bob, length=.0001)
aliceDQ = DistributedQueue(alice, conn)
bobDQ = DistributedQueue(bob, conn)
aliceProto = TestProtocol(alice, aliceDQ, 1)
bobProto = TestProtocol(bob, bobDQ, 1)
nodes = [
(alice, [aliceProto]),
(bob, [bobProto]),
]
conns = [(conn, "dqp_conn", [aliceProto, bobProto])]
network = EasyNetwork(name="DistQueueNetwork",
nodes=nodes,
connections=conns)
network.start()
sim_run(1000)
# Check the Queue contains ordered elements from Alice and Bob
queueA = aliceDQ.queueList[0]
queueB = bobDQ.queueList[0]
qA = queueA.sequence_to_item
qB = queueB.sequence_to_item
# Make all the items ready
for seq in qA:
queueA.ack(seq)
queueA.ready(seq)
for seq in qB:
queueB.ack(seq)
queueB.ready(seq)
# First they should have the same length
self.assertGreater(len(qA), 0)
self.assertEqual(len(qA), len(qB))
# Check the items are the same and the sequence numbers are ordered
count = 0
for k in range(len(qA)):
self.assertEqual(qA[k].request, qB[k].request)
self.assertEqual(qA[k].seq, qB[k].seq)
self.assertEqual(qA[k].seq, count)
count = count + 1
# Check that we can remove the items (locally) at both nodes
rqid = 0
rqseqs = set([randint(0, len(qA) - 1) for t in range(10)])
for qseq in rqseqs:
q_item = aliceDQ.remove_item(rqid, qseq)
self.assertIsNotNone(q_item)
self.assertFalse(aliceDQ.queueList[rqid].contains(qseq))
# Check that we can pop the remaining items in the correct order
remaining = set(range(len(qB))) - rqseqs
for qseq in remaining:
q_item = aliceDQ.local_pop(rqid)
self.assertEqual(q_item.seq, qseq)
self.assertIsNotNone(q_item)
def test_lossy_comms_wraparound(self):
sim_reset()
node = QuantumNode("TestNode 1", 1)
node2 = QuantumNode("TestNode 2", 2)
conn = ClassicalFibreConnection(node, node2, length=0.1)
dq = DistributedQueue(node,
conn,
numQueues=3,
throw_local_queue_events=True)
dq2 = DistributedQueue(node2,
conn,
numQueues=3,
throw_local_queue_events=True)
dq.connect_to_peer_protocol(dq2, conn)
self.lost_messages = 0
self.lost_seq = dq.myWsize + 1
def faulty_send_msg(cmd, data, clock):
if self.lost_messages == 0 and clock[0] == self.lost_seq:
self.lost_messages += 1
else:
dq.conn.put_from(dq.myID, (cmd, data, clock))
dq.send_msg = faulty_send_msg
nodes = [
(node, [dq]),
(node2, [dq2]),
]
conns = [(conn, "dq_conn", [dq, dq2])]
network = EasyNetwork(name="DistQueueNetwork",
nodes=nodes,
connections=conns)
network.start()
num_adds = 0
r = 1
curr_time = 0
import pdb
while num_adds < 2 * dq.maxCommsSeq:
add_delay = 2
for i in range(dq.myWsize):
request = SchedulerRequest(0, 0, 0, 0, i, 0, 0, True, False,
False, True)
dq.add(request)
sim_run(curr_time + (i + 1) * add_delay)
curr_time += add_delay
for j in range(dq2.myWsize):
request = SchedulerRequest(0, 0, 0, 0, j, 0, 0, True, False,
False, True)
dq2.add(request)
sim_run(curr_time + (j + 1) * add_delay)
curr_time += add_delay
num_adds += dq.myWsize
num_adds += dq2.myWsize
run_time = r * dq.comm_delay * 4
sim_run(curr_time + run_time)
curr_time += run_time
r += 1
self.ready_items(dq.queueList[0])
self.ready_items(dq2.queueList[0])
self.check_local_queues(dq.queueList[0], dq2.queueList[0])
for i in range(dq.myWsize + dq2.myWsize):
dq.local_pop()
dq2.local_pop()
def test_random_add_remove(self):
sim_reset()
node = QuantumNode("TestNode 1", 1)
node2 = QuantumNode("TestNode 2", 2)
conn = ClassicalFibreConnection(node, node2, length=25)
dq = DistributedQueue(node,
conn,
numQueues=3,
throw_local_queue_events=True)
dq2 = DistributedQueue(node2,
conn,
numQueues=3,
throw_local_queue_events=True)
dq.connect_to_peer_protocol(dq2, conn)
nodes = [
(node, [dq]),
(node2, [dq2]),
]
conns = [(conn, "dq_conn", [dq, dq2])]
network = EasyNetwork(name="DistQueueNetwork",
nodes=nodes,
connections=conns)
network.start()
create_id = 0
for _ in range(20):
# Add random requests to master
num_reqs_master = randint(0, 3)
for _ in range(num_reqs_master):
request = SchedulerRequest(0, 0, 0, 0, create_id, 0, 0, True,
False, False, True)
try:
dq.add(request=request, qid=0)
except LinkLayerException:
# Full queue
pass
create_id += 1
# Add random requests to slave
num_reqs_slave = randint(0, 3)
for _ in range(num_reqs_slave):
request = SchedulerRequest(0, 0, 0, 0, create_id, 0, 0, True,
False, False, True)
try:
dq2.add(request=request, qid=0)
except LinkLayerException:
# Full queue
pass
create_id += 1
# Randomly remove things for both
num_pop = randint(0, 6)
for _ in range(num_pop):
dq.local_pop(qid=0)
# Run for random fraction of timeout
r = randint(1, 20)
run_time = dq.comm_delay * dq.timeout_factor * (r / 10)
sim_run(run_time)
# Make sure things are not in flight
sim_run()
self.ready_items(dq.queueList[0])
self.ready_items(dq2.queueList[0])
self.check_local_queues(dq.queueList[0], dq2.queueList[0])
# Add one request for both master and slave
create_id = 0
request = SchedulerRequest(0, 0, 0, 0, create_id, 0, 0, True, False,
False, True)
dq.add(request=request, qid=0)
create_id = 1
request = SchedulerRequest(0, 0, 0, 0, create_id, 0, 0, True, False,
False, True)
dq2.add(request=request, qid=0)