def setUp(self):
def timeout_handler(aid, request):
self.timeout_handler_called[0] = True
self.timeout_handler_called = [False]
sim_reset()
memA = NVCommunicationDevice(name="AMem", num_positions=2)
memB = NVCommunicationDevice(name="BMem", num_positions=2)
nodeA = QuantumNode(name="TestA", nodeID=1, memDevice=memA)
nodeB = QuantumNode(name="TestB", nodeID=2, memDevice=memB)
dqpA = EGPDistributedQueue(node=nodeA, accept_all=True)
dqpB = EGPDistributedQueue(node=nodeB, accept_all=True)
dqpA.connect_to_peer_protocol(dqpB)
qmm = QuantumMemoryManagement(node=nodeA)
self.test_scheduler = StrictPriorityRequestScheduler(distQueue=dqpA,
qmm=qmm)
conn = dqpA.conn
network = EasyNetwork(name="DQPNetwork",
nodes=[(nodeA, [dqpA]), (nodeB, [dqpB])],
connections=[(conn, "dqp_conn", [dqpA, dqpB])])
network.start()
increase_mhp_cycle_protocol = IncreasMHPCycleProtocol(
scheduler=self.test_scheduler)
increase_mhp_cycle_protocol.start()
self.test_scheduler.set_timeout_callback(timeout_handler)
def test__init_queues(self):
node = QuantumNode("test", nodeID=1)
dq = EGPDistributedQueue(node)
dq._init_queues(2)
self.assertEqual(len(dq.queueList), 2)
self.assertEqual(dq.numLocalQueues, 2)
for q in dq.queueList:
self.assertIsInstance(q, EGPLocalQueue)
def setUp(self):
memA = NVCommunicationDevice(name="AMem", num_positions=2)
memB = NVCommunicationDevice(name="BMem", num_positions=2)
self.nodeA = QuantumNode(name="TestA", nodeID=1, memDevice=memA)
self.nodeB = QuantumNode(name="TestB", nodeID=2, memDevice=memB)
self.dqpA = EGPDistributedQueue(node=self.nodeA)
self.dqpB = EGPDistributedQueue(node=self.nodeB)
self.dqpA.connect_to_peer_protocol(self.dqpB)
def test_init(self):
def callback(queue_item):
pass
node = QuantumNode("test", nodeID=1)
dq = EGPDistributedQueue(node)
self.assertIs(dq.timeout_callback, None)
dq = EGPDistributedQueue(node, timeout_callback=callback)
self.assertIs(dq.timeout_callback, callback)
def test_set_timeout_callback(self):
def callback1(queue_item):
pass
def callback2(queue_item):
pass
node = QuantumNode("test", nodeID=1)
dq = EGPDistributedQueue(node, timeout_callback=callback1)
self.assertIs(dq.timeout_callback, callback1)
dq = EGPDistributedQueue(node, timeout_callback=callback2)
self.assertIs(dq.timeout_callback, callback2)
def test_multiple_queues(self):
sim_reset()
alice = QuantumNode("alice", nodeID=0)
bob = QuantumNode("bob", nodeID=1)
conn = ClassicalFibreConnection(alice, bob, length=.0001)
aliceDQ = EGPDistributedQueue(alice,
conn,
accept_all=True,
numQueues=2)
bobDQ = EGPDistributedQueue(bob, conn, accept_all=True, numQueues=2)
nodes = [
(alice, [aliceDQ]),
(bob, [bobDQ]),
]
conns = [(conn, "dqp_conn", [aliceDQ, bobDQ])]
network = EasyNetwork(name="DistQueueNetwork",
nodes=nodes,
connections=conns)
network.start()
alice_requests = [SchedulerRequest(), SchedulerRequest()]
bob_requests = [SchedulerRequest(), SchedulerRequest()]
aliceDQ.add(alice_requests[0], qid=0)
aliceDQ.add(alice_requests[1], qid=1)
bobDQ.add(bob_requests[0], qid=0)
bobDQ.add(bob_requests[1], qid=1)
sim_run(10)
self.assertEqual(len(aliceDQ.queueList[0].queue), 2)
self.assertEqual(len(aliceDQ.queueList[1].queue), 2)
self.assertEqual(len(bobDQ.queueList[0].queue), 2)
self.assertEqual(len(bobDQ.queueList[1].queue), 2)
def test_priority(self):
sim_reset()
num_priorities = 10
dqpA = EGPDistributedQueue(node=self.nodeA,
accept_all=True,
numQueues=num_priorities)
dqpB = EGPDistributedQueue(node=self.nodeB,
accept_all=True,
numQueues=num_priorities)
dqpA.connect_to_peer_protocol(dqpB)
qmmA = QuantumMemoryManagement(node=self.nodeA)
test_scheduler = StrictPriorityRequestScheduler(distQueue=dqpA,
qmm=qmmA)
test_scheduler.configure_mhp_timings(1, 2, 0, 0)
requests = [
EGPRequest(other_id=self.nodeB.nodeID,
num_pairs=1,
min_fidelity=1,
max_time=0,
purpose_id=0,
priority=i) for i in range(num_priorities)
]
conn = dqpA.conn
self.network = EasyNetwork(name="DQPNetwork",
nodes=[(self.nodeA, [dqpA]),
(self.nodeB, [dqpB])],
connections=[(conn, "dqp_conn",
[dqpA, dqpB])])
self.network.start()
for i, request in enumerate(reversed(requests)):
test_scheduler.add_request(request)
sim_run(i * 5)
for cycle in range(2 * test_scheduler.mhp_cycle_offset):
test_scheduler.inc_cycle()
for i in range(num_priorities):
next_aid, next_request = test_scheduler._get_next_request()
self.assertEqual((i, 0), next_aid)
self.assertEqual(next_request.priority, i)
test_scheduler.clear_request(next_aid)
def test_faulty_queue_ID(self):
def add_callback(result):
self.assertEqual(result[0], aliceDQ.DQ_REJECT)
callback_called[0] = True
sim_reset()
callback_called = [False]
alice = QuantumNode("alice", nodeID=0)
bob = QuantumNode("bob", nodeID=1)
conn = ClassicalFibreConnection(alice, bob, length=.0001)
aliceDQ = EGPDistributedQueue(alice,
conn,
accept_all=True,
numQueues=1)
bobDQ = EGPDistributedQueue(bob, conn, accept_all=True, numQueues=1)
aliceDQ.add_callback = add_callback
nodes = [
(alice, [aliceDQ]),
(bob, [bobDQ]),
]
conns = [(conn, "dqp_conn", [aliceDQ, bobDQ])]
network = EasyNetwork(name="DistQueueNetwork",
nodes=nodes,
connections=conns)
network.start()
request = SchedulerRequest()
aliceDQ.add(request, qid=1)
sim_run(10)
self.assertTrue(callback_called[0])
def test_update_mhp_cycle_number(self):
def callback_alice(queue_item):
callback_called[0] = True
def callback_bob(queue_item):
callback_called[1] = True
sim_reset()
callback_called = [False, False]
alice = QuantumNode("alice", nodeID=0)
bob = QuantumNode("bob", nodeID=1)
conn = ClassicalFibreConnection(alice, bob, length=.0001)
aliceDQ = EGPDistributedQueue(alice,
conn,
timeout_callback=callback_alice,
accept_all=True)
bobDQ = EGPDistributedQueue(bob,
conn,
timeout_callback=callback_bob,
accept_all=True)
nodes = [
(alice, [aliceDQ]),
(bob, [bobDQ]),
]
conns = [(conn, "dqp_conn", [aliceDQ, bobDQ])]
network = EasyNetwork(name="DistQueueNetwork",
nodes=nodes,
connections=conns)
network.start()
request = SchedulerRequest(sched_cycle=1, timeout_cycle=2)
aliceDQ.add(request, 0)
sim_run(10)
queue_item_alice = aliceDQ.local_peek(0)
queue_item_bob = bobDQ.local_peek(0)
self.assertFalse(queue_item_alice.ready)
aliceDQ.update_mhp_cycle_number(1, 10)
self.assertTrue(queue_item_alice.ready)
self.assertFalse(queue_item_bob.ready)
self.assertFalse(callback_called[0])
self.assertFalse(callback_called[1])
aliceDQ.update_mhp_cycle_number(2, 10)
self.assertTrue(callback_called[0])
self.assertFalse(callback_called[1])
bobDQ.update_mhp_cycle_number(1, 10)
self.assertTrue(queue_item_bob.ready)
self.assertFalse(callback_called[1])
bobDQ.update_mhp_cycle_number(2, 10)
self.assertTrue(queue_item_bob.ready)
self.assertTrue(callback_called[1])
def test_next(self):
sim_reset()
dqpA = EGPDistributedQueue(node=self.nodeA, accept_all=True)
dqpB = EGPDistributedQueue(node=self.nodeB, accept_all=True)
dqpA.connect_to_peer_protocol(dqpB)
qmmA = QuantumMemoryManagement(node=self.nodeA)
test_scheduler = StrictPriorityRequestScheduler(distQueue=dqpA,
qmm=qmmA)
test_scheduler.configure_mhp_timings(1, 2, 0, 0)
request = EGPRequest(other_id=self.nodeB.nodeID,
num_pairs=1,
min_fidelity=1,
max_time=0,
purpose_id=0,
priority=0)
conn = dqpA.conn
self.network = EasyNetwork(name="DQPNetwork",
nodes=[(self.nodeA, [dqpA]),
(self.nodeB, [dqpB])],
connections=[(conn, "dqp_conn",
[dqpA, dqpB])])
self.network.start()
# Check that an empty queue has a default request
self.assertEqual(test_scheduler.get_default_gen(),
test_scheduler.next())
# Check that an item not agreed upon also yields a default request
test_scheduler.add_request(request)
self.assertEqual(test_scheduler.get_default_gen(),
test_scheduler.next())
for i in range(11):
sim_run(11)
test_scheduler.inc_cycle()
self.assertEqual(test_scheduler.get_default_gen(),
test_scheduler.next())
test_scheduler.inc_cycle()
# Check that QMM reserve failure yields a default request
comm_q = qmmA.reserve_communication_qubit()
storage_q = [
qmmA.reserve_storage_qubit() for _ in range(request.num_pairs)
]
self.assertEqual(test_scheduler.get_default_gen(),
test_scheduler.next())
# Return the reserved resources
qmmA.vacate_qubit(comm_q)
for q in storage_q:
qmmA.vacate_qubit(q)
# Check that lack of peer resources causes a default request
self.assertEqual(test_scheduler.get_default_gen(),
test_scheduler.next())
# Verify that now we can obtain the next request
test_scheduler.other_mem = (1, request.num_pairs)
# Verify that the next request is the one we submitted
gen = test_scheduler.next()
self.assertEqual(gen, (True, (0, 0), 0, 1, {}))
class TestRequestScheduler(unittest.TestCase):
def setUp(self):
memA = NVCommunicationDevice(name="AMem", num_positions=2)
memB = NVCommunicationDevice(name="BMem", num_positions=2)
self.nodeA = QuantumNode(name="TestA", nodeID=1, memDevice=memA)
self.nodeB = QuantumNode(name="TestB", nodeID=2, memDevice=memB)
self.dqpA = EGPDistributedQueue(node=self.nodeA)
self.dqpB = EGPDistributedQueue(node=self.nodeB)
self.dqpA.connect_to_peer_protocol(self.dqpB)
def test_init(self):
qmm = QuantumMemoryManagement(node=self.nodeA)
with self.assertRaises(TypeError):
StrictPriorityRequestScheduler()
with self.assertRaises(TypeError):
StrictPriorityRequestScheduler(distQueue=self.dqpA)
with self.assertRaises(TypeError):
StrictPriorityRequestScheduler(qmm=qmm)
test_scheduler = StrictPriorityRequestScheduler(distQueue=self.dqpA,
qmm=qmm)
self.assertEqual(test_scheduler.distQueue, self.dqpA)
self.assertEqual(test_scheduler.qmm, qmm)
self.assertEqual(test_scheduler.my_free_memory, qmm.get_free_mem_ad())
self.assertEqual(test_scheduler.other_mem, (0, 0))
def test_choose_queue(self):
qmm = QuantumMemoryManagement(node=self.nodeA)
request = EGPRequest(
EGPSimulationScenario.construct_cqc_epr_request(
otherID=self.nodeB.nodeID,
num_pairs=1,
min_fidelity=1,
max_time=1,
purpose_id=0,
priority=0))
test_scheduler = StrictPriorityRequestScheduler(distQueue=self.dqpA,
qmm=qmm)
self.assertEqual(test_scheduler.choose_queue(request), 0)
def test_update_other_mem_size(self):
qmm = QuantumMemoryManagement(node=self.nodeA)
test_scheduler = StrictPriorityRequestScheduler(distQueue=self.dqpA,
qmm=qmm)
test_size = 3
test_scheduler.update_other_mem_size(mem=test_size)
def test_next(self):
sim_reset()
dqpA = EGPDistributedQueue(node=self.nodeA, accept_all=True)
dqpB = EGPDistributedQueue(node=self.nodeB, accept_all=True)
dqpA.connect_to_peer_protocol(dqpB)
qmmA = QuantumMemoryManagement(node=self.nodeA)
test_scheduler = StrictPriorityRequestScheduler(distQueue=dqpA,
qmm=qmmA)
test_scheduler.configure_mhp_timings(1, 2, 0, 0)
request = EGPRequest(other_id=self.nodeB.nodeID,
num_pairs=1,
min_fidelity=1,
max_time=0,
purpose_id=0,
priority=0)
conn = dqpA.conn
self.network = EasyNetwork(name="DQPNetwork",
nodes=[(self.nodeA, [dqpA]),
(self.nodeB, [dqpB])],
connections=[(conn, "dqp_conn",
[dqpA, dqpB])])
self.network.start()
# Check that an empty queue has a default request
self.assertEqual(test_scheduler.get_default_gen(),
test_scheduler.next())
# Check that an item not agreed upon also yields a default request
test_scheduler.add_request(request)
self.assertEqual(test_scheduler.get_default_gen(),
test_scheduler.next())
for i in range(11):
sim_run(11)
test_scheduler.inc_cycle()
self.assertEqual(test_scheduler.get_default_gen(),
test_scheduler.next())
test_scheduler.inc_cycle()
# Check that QMM reserve failure yields a default request
comm_q = qmmA.reserve_communication_qubit()
storage_q = [
qmmA.reserve_storage_qubit() for _ in range(request.num_pairs)
]
self.assertEqual(test_scheduler.get_default_gen(),
test_scheduler.next())
# Return the reserved resources
qmmA.vacate_qubit(comm_q)
for q in storage_q:
qmmA.vacate_qubit(q)
# Check that lack of peer resources causes a default request
self.assertEqual(test_scheduler.get_default_gen(),
test_scheduler.next())
# Verify that now we can obtain the next request
test_scheduler.other_mem = (1, request.num_pairs)
# Verify that the next request is the one we submitted
gen = test_scheduler.next()
self.assertEqual(gen, (True, (0, 0), 0, 1, {}))
def test_priority(self):
sim_reset()
num_priorities = 10
dqpA = EGPDistributedQueue(node=self.nodeA,
accept_all=True,
numQueues=num_priorities)
dqpB = EGPDistributedQueue(node=self.nodeB,
accept_all=True,
numQueues=num_priorities)
dqpA.connect_to_peer_protocol(dqpB)
qmmA = QuantumMemoryManagement(node=self.nodeA)
test_scheduler = StrictPriorityRequestScheduler(distQueue=dqpA,
qmm=qmmA)
test_scheduler.configure_mhp_timings(1, 2, 0, 0)
requests = [
EGPRequest(other_id=self.nodeB.nodeID,
num_pairs=1,
min_fidelity=1,
max_time=0,
purpose_id=0,
priority=i) for i in range(num_priorities)
]
conn = dqpA.conn
self.network = EasyNetwork(name="DQPNetwork",
nodes=[(self.nodeA, [dqpA]),
(self.nodeB, [dqpB])],
connections=[(conn, "dqp_conn",
[dqpA, dqpB])])
self.network.start()
for i, request in enumerate(reversed(requests)):
test_scheduler.add_request(request)
sim_run(i * 5)
for cycle in range(2 * test_scheduler.mhp_cycle_offset):
test_scheduler.inc_cycle()
for i in range(num_priorities):
next_aid, next_request = test_scheduler._get_next_request()
self.assertEqual((i, 0), next_aid)
self.assertEqual(next_request.priority, i)
test_scheduler.clear_request(next_aid)