More tests

Author: Axel Dahlberg

qlinklayer/scheduler.py

@@ -810,7 +810,7 @@ def __init__(self, distQueue, qmm, feu, weights=None):
         :param feu: :obj:`~qlinklayer.feu.FidelityEstimationUnit`
             (optional) The fidelity estimation unit
         :param weights: None, list of floats
-            * If None, a strict priority queue will be used, with the queue IDs as priorities
+            * If None, a unweighted fair queue will be used, (i.e. equal weights)
             * 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
@@ -853,7 +853,7 @@ def _compare_mhp_cycle(self, cycle1, cycle2):
 
     def _get_relative_weights(self, weights):
         if weights is None:
-            return [0] * len(self.distQueue.queueList)
+            return [1] * len(self.distQueue.queueList)
         if not isinstance(weights, list) or isinstance(weights, tuple):
             raise TypeError("Weights need to be None or list")
         if not len(weights) == len(self.distQueue.queueList):
@@ -918,10 +918,13 @@ def set_virtual_finish(self, scheduler_request, qid):
             est_nr_cycles_per_pair = self._estimate_nr_of_cycles_per_pair(scheduler_request)
 
             # Check if this is an atomic request
+            # Compute initial virt finish (if non-atomic this will be updated per success)
             if scheduler_request.atomic:
                 virt_duration = est_nr_cycles_per_pair * scheduler_request.num_pairs
+                self.last_virt_finish[qid] = virt_start + virt_duration / self.relative_weights[qid]
             else:
                 virt_duration = est_nr_cycles_per_pair
+                self.last_virt_finish[qid] = virt_start + virt_duration * scheduler_request.num_pairs /self.relative_weights[qid]
 
             # Compute initial virt finish (if non-atomic this will be updated per success)
             init_virt_finish = virt_start + virt_duration / self.relative_weights[qid]

tests/test_scheduler.py

@@ -10,7 +10,7 @@
 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
+from qlinklayer.scheduler import StrictPriorityRequestScheduler, WFQRequestScheduler, SchedulerRequest
 from qlinklayer.qmm import QuantumMemoryManagement
 from qlinklayer.egp import EGPRequest
 from qlinklayer.scenario import EGPSimulationScenario
@@ -183,7 +183,7 @@ def setUp(self):
     def test_init(self):
         # Test default
         scheduler = WFQRequestScheduler(self.distQueueA, self.qmmA, self.feuA)
-        self.assertEqual(scheduler.relative_weights, [0] * self.num_queues)
+        self.assertEqual(scheduler.relative_weights, [1] * self.num_queues)
 
         # Test wrong type
         with self.assertRaises(TypeError):
@@ -215,12 +215,65 @@ def test_compare_cycle_odd(self):
         cycle1 = 0
         cycle2 = 1
 
-        for _ in range(scheduler.max_mhp_cycle_number):
-            print(scheduler._compare_mhp_cycle(cycle1, cycle2))
+        for i in range(scheduler.max_mhp_cycle_number):
+            if i == 3:
+                self.assertEqual(scheduler._compare_mhp_cycle(cycle1, cycle2), 1)
+            else:
+                self.assertEqual(scheduler._compare_mhp_cycle(cycle1, cycle2), -1)
+            self.assertEqual(scheduler._compare_mhp_cycle(cycle1, cycle1), 0)
+            self.assertEqual(scheduler._compare_mhp_cycle(cycle2, cycle2), 0)
             scheduler.mhp_cycle_number += 1
 
-    def test_set_virtual_finish(self):
-        pass
+    def test_compare_cycle_even(self):
+        scheduler = WFQRequestScheduler(self.distQueueA, self.qmmA, self.feuA)
+        scheduler.max_mhp_cycle_number = 6
+        scheduler.mhp_cycle_number = 0
+
+        cycle1 = 0
+        cycle2 = 1
+
+        for i in range(scheduler.max_mhp_cycle_number):
+            if i == 4:
+                self.assertEqual(scheduler._compare_mhp_cycle(cycle1, cycle2), 1)
+            else:
+                self.assertEqual(scheduler._compare_mhp_cycle(cycle1, cycle2), -1)
+            self.assertEqual(scheduler._compare_mhp_cycle(cycle1, cycle1), 0)
+            self.assertEqual(scheduler._compare_mhp_cycle(cycle2, cycle2), 0)
+            scheduler.mhp_cycle_number += 1
+
+    def test_set_virtual_finish_same_queue_same_req(self):
+        scheduler = WFQRequestScheduler(self.distQueueA, self.qmmA, self.feuA)
+
+        # Compare high and low min_fidelity
+        requests = [SchedulerRequest(), SchedulerRequest()]
+        wfq_requests = []
+        for req in requests:
+            wfq_requests.append(scheduler.set_virtual_finish(req, 0))
+        self.assertGreater(wfq_requests[0].init_virtual_finish, wfq_requests[1].init_virtual_finish)
+        self.assertEqual(wfq_requests[0].est_cycles_per_pair, wfq_requests[1].est_cycles_per_pair)
+        self.assertEqual(wfq_requests[0].init_virtual_finish + wfq_requests[0].est_cycles_per_pair, wfq_requests[1].init_virtual_finish)
+
+    def test_set_virtual_finish_fidelity(self):
+        scheduler = WFQRequestScheduler(self.distQueueA, self.qmmA, self.feuA)
+
+        # Compare high and low min_fidelity
+        requests = [SchedulerRequest(min_fidelity=0.8), SchedulerRequest(min_fidelity=0.6)]
+        wfq_requests = []
+        for qid, req in enumerate(requests):
+            wfq_requests.append(scheduler.set_virtual_finish(req, qid))
+        self.assertGreater(wfq_requests[0].init_virtual_finish, wfq_requests[1].init_virtual_finish)
+        self.assertGreater(wfq_requests[0].est_cycles_per_pair, wfq_requests[1].est_cycles_per_pair)
+
+    def test_set_virtual_finish_num_pairs(self):
+        scheduler = WFQRequestScheduler(self.distQueueA, self.qmmA, self.feuA)
+
+        # Compare high and low num pairs (non atomic)
+        requests = [SchedulerRequest(num_pairs=2), SchedulerRequest(num_pairs=10)]
+        wfq_requests = []
+        for qid, req in enumerate(requests):
+            wfq_requests.append(scheduler.set_virtual_finish(req, qid))
+        self.assertEqual(wfq_requests[0].init_virtual_finish, wfq_requests[1].init_virtual_finish)
+        self.assertEqual(wfq_requests[0].est_cycles_per_pair, wfq_requests[1].est_cycles_per_pair)
 
     def test_scheduling(self):
         pass