Continued with tests for WFQ

Author: Axel Dahlberg

qlinklayer/scheduler.py

@@ -52,7 +52,7 @@ class StrictPriorityRequestScheduler(Scheduler):
     # The scheduler request named tuple to use
     _scheduler_request_named_tuple = SchedulerRequest
 
-    def __init__(self, distQueue, qmm, feu=None):
+    def __init__(self, distQueue, qmm, feu):
         """
         Stub for a scheduler to decide how we assign and consume elements of the queue.
         This scheduler puts requests in queues depending on only their specified priority
@@ -797,7 +797,7 @@ class WFQRequestScheduler(StrictPriorityRequestScheduler):
     # The scheduler request named tuple to use
     _scheduler_request_named_tuple = WFQSchedulerRequest
 
-    def __init__(self, distQueue, qmm, feu=None, weights=None):
+    def __init__(self, distQueue, qmm, feu, weights=None):
         """
         Stub for a scheduler to decide how we assign and consume elements of the queue.
         This weighted fair queue (WFQ) scheduler implements a weighted fair queue where queue i
@@ -810,7 +810,7 @@ def __init__(self, distQueue, qmm, feu=None, weights=None):
         :param feu: :obj:`~qlinklayer.feu.FidelityEstimationUnit`
             (optional) The fidelity estimation unit
         :param weights: None, list of floats
-            * If None, a fair queue with equal weights will be used.
+            * If None, a strict priority queue will be used, with the queue IDs as priorities
             * If list of floats, the length of the list needs to equal the number of queues in the distributed queue.
               The floats need to be non-zero. If a weight is zero, this is seen as infinite weight and queues with zero
               weight will always be scheduled before other queues. If multiple queues have weight zero, then
@@ -820,7 +820,7 @@ def __init__(self, distQueue, qmm, feu=None, weights=None):
 
         self.relative_weights = self._get_relative_weights(weights)
 
-        self.last_virt_finish = [-1] * len(weights)
+        self.last_virt_finish = [-1] * len(self.relative_weights)
 
     def _compare_mhp_cycle(self, cycle1, cycle2):
         """
@@ -853,9 +853,9 @@ def _compare_mhp_cycle(self, cycle1, cycle2):
 
     def _get_relative_weights(self, weights):
         if weights is None:
-            return
+            return [0] * len(self.distQueue.queueList)
         if not isinstance(weights, list) or isinstance(weights, tuple):
-            raise ValueError("Weights need to be None or list")
+            raise TypeError("Weights need to be None or list")
         if not len(weights) == len(self.distQueue.queueList):
             raise ValueError("Number of weights must equal number of queues")
         for weight in weights:

tests/test_scheduler.py

@@ -1,11 +1,13 @@
 import unittest
 import logging
+from util.config_paths import ConfigPathStorage
 from easysquid.easyfibre import ClassicalFibreConnection
-from easysquid.easynetwork import EasyNetwork
+from easysquid.easynetwork import EasyNetwork, setup_physical_network
 from easysquid.qnode import QuantumNode
 from easysquid.quantumMemoryDevice import NVCommunicationDevice
 from easysquid.easyprotocol import TimedProtocol
 from easysquid.toolbox import logger
+from easysquid.quantumMemoryDevice import NVCommunicationDevice
 from netsquid.simutil import sim_run, sim_reset
 from qlinklayer.distQueue import EGPDistributedQueue, WFQDistributedQueue
 from qlinklayer.scheduler import StrictPriorityRequestScheduler, WFQRequestScheduler
@@ -155,24 +157,75 @@ def test_priority(self):
 
 class TestWFQRequestScheduler(unittest.TestCase):
     def setUp(self):
-        alice = QuantumNode("alice", 0)
-        bob = QuantumNode("bob", 0)
-        conn = ClassicalFibreConnection(alice, bob, length=0.001)
+        sim_reset()
+
+        network = setup_physical_network(ConfigPathStorage.NETWORK_NV_LAB_NOCAV_NOCONV)
+        alice, bob = network.all_nodes()
+        dqp_conn = network.get_connection(alice, bob, "dqp_conn")
+        mhp_conn = network.get_connection(alice, bob, "mhp_conn")
 
-        distQueueA = WFQDistributedQueue(alice, numQueues=3, accept_all=True)
-        distQueueB = WFQDistributedQueue(bob, numQueues=3, accept_all=True)
-        distQueueA.connect_to_peer_protocol(distQueueB, conn=conn)
+        self.num_queues = 3
 
-        qmmA = QuantumMemoryManagement(alice)
+        self.distQueueA = WFQDistributedQueue(alice, numQueues=self.num_queues, accept_all=True)
+        distQueueB = WFQDistributedQueue(bob, numQueues=self.num_queues, accept_all=True)
+        self.distQueueA.connect_to_peer_protocol(distQueueB, conn=dqp_conn)
+
+        self.qmmA = QuantumMemoryManagement(alice)
         qmmB = QuantumMemoryManagement(bob)
 
-        # mhp_service = SimulatedNodeCentricMHPService("mhp_service", alice, bob)
-        #
-        # feuA = SingleClickFidelityEstimationUnit(alice, )
-        # self.schedulerA = WFQRequestScheduler(distQueueA, qmmA, feuA)
+        mhp_service = SimulatedNodeCentricMHPService("mhp_service", alice, bob, conn=mhp_conn)
+
+        self.feuA = SingleClickFidelityEstimationUnit(alice, mhp_service)
+        feuB = SingleClickFidelityEstimationUnit(bob, mhp_service)
+
+        self.schedulerA = WFQRequestScheduler(self.distQueueA, self.qmmA, self.feuA)
+
     def test_init(self):
+        # Test default
+        scheduler = WFQRequestScheduler(self.distQueueA, self.qmmA, self.feuA)
+        self.assertEqual(scheduler.relative_weights, [0] * self.num_queues)
+
+        # Test wrong type
+        with self.assertRaises(TypeError):
+            WFQRequestScheduler(self.distQueueA, self.qmmA, self.feuA, 0)
+        with self.assertRaises(TypeError):
+            WFQRequestScheduler(self.distQueueA, self.qmmA, self.feuA, {})
+
+        # Test wrong length
+        with self.assertRaises(ValueError):
+            WFQRequestScheduler(self.distQueueA, self.qmmA, self.feuA, [0] * (self.num_queues + 1))
+
+        # Test negative weights
+        with self.assertRaises(ValueError):
+            WFQRequestScheduler(self.distQueueA, self.qmmA, self.feuA, [0, 0, -1])
+
+        # Test non-comparable weights
+        with self.assertRaises(ValueError):
+            WFQRequestScheduler(self.distQueueA, self.qmmA, self.feuA, [0, [], False])
+
+        # Test non-trivial weights
+        scheduler = WFQRequestScheduler(self.distQueueA, self.qmmA, self.feuA, [0, 5, 15])
+        self.assertEqual(scheduler.relative_weights, [0, 0.25, 0.75])
+
+    def test_compare_cycle_odd(self):
+        scheduler = WFQRequestScheduler(self.distQueueA, self.qmmA, self.feuA)
+        scheduler.max_mhp_cycle_number = 5
+        scheduler.mhp_cycle_number = 0
+
+        cycle1 = 0
+        cycle2 = 1
+
+        for _ in range(scheduler.max_mhp_cycle_number):
+            print(scheduler._compare_mhp_cycle(cycle1, cycle2))
+            scheduler.mhp_cycle_number += 1
+
+    def test_set_virtual_finish(self):
         pass
 
+    def test_scheduling(self):
+        pass
+
+
 
 class TestTimings(unittest.TestCase):
     def setUp(self):