feat: Metrics tracking system for entanglement management

sequence/entanglement_management/generation/barret_kok.py

@@ -13,7 +13,8 @@
 
 from ...kernel.event import Event
 from ...kernel.process import Process
-from ...utils import log
+from ...utils import log, metrics
+from ...utils.metrics.event_types import EventTypes
 
 
 @EntanglementGenerationA.register(BARRET_KOK)
@@ -225,6 +226,12 @@ def _entanglement_succeed(self):
         self.memory.entangled_memory['node_id'] = self.remote_node_name
         self.memory.entangled_memory['memo_id'] = self.remote_memo_id
         self.memory.fidelity = self.memory.raw_fidelity
+        metrics.record(
+            EventTypes.EG_SUCCESS,
+            self.owner.name,
+            remote_node=self.remote_node_name,
+            fidelity=self.fidelity,
+        )
         self.update_resource_manager(self.memory, MemoryInfo.ENTANGLED)
 
 

sequence/entanglement_management/generation/generation_base.py

@@ -12,7 +12,8 @@
 
 from ..entanglement_protocol import EntanglementProtocol
 from ...components.circuit import Circuit
-from ...utils import log
+from ...utils import log, metrics
+from ...utils.metrics.event_types import EventTypes
 
 
 class QuantumCircuitMixin:
@@ -180,6 +181,12 @@ def _entanglement_succeed(self):
     def _entanglement_fail(self):
         for event in self.scheduled_events:
             self.owner.timeline.remove_event(event)
+        metrics.record(
+            EventTypes.EG_FAILURE,
+            self.owner.name,
+            remote_node=self.remote_node_name,
+            fidelity=self.fidelity,
+        )
         log.logger.info(f'{self.owner.name} failed entanglement of memory {self.memory}')
 
         self.update_resource_manager(self.memory, MemoryInfo.RAW)

sequence/entanglement_management/generation/single_heralded.py

@@ -11,7 +11,8 @@
 from ...kernel.process import Process
 from ...kernel.quantum_manager import QuantumManager
 from ...resource_management.memory_manager import MemoryInfo
-from ...utils import log
+from ...utils import log, metrics
+from ...utils.metrics.event_types import EventTypes
 
 if TYPE_CHECKING:
     from ...components.memory import Memory
@@ -230,6 +231,12 @@ def _entanglement_succeed(self):
         log.logger.info(f'{self.owner.name} successful entanglement of memory {self.memory}')
         self.memory.entangled_memory['node_id'] = self.remote_node_name
         self.memory.entangled_memory['memo_id'] = self.remote_memo_id
+        metrics.record(
+            EventTypes.EG_SUCCESS,
+            self.owner.name,
+            remote_node=self.remote_node_name,
+            fidelity=self.raw_fidelity,
+        )
         self.memory.fidelity = self.raw_fidelity
 
         self.update_resource_manager(self.memory, MemoryInfo.ENTANGLED)

sequence/entanglement_management/purification/bbpssw_bds.py

@@ -16,7 +16,8 @@
     from ...topology.node import Node
 
 from ...constants import BELL_DIAGONAL_STATE_FORMALISM
-from ...utils import log
+from ...utils import log, metrics
+from ...utils.metrics.event_types import EventTypes
 from .bbpssw_protocol import BBPSSWProtocol, BBPSSWMessage, BBPSSWMsgType
 
 @BBPSSWProtocol.register(BELL_DIAGONAL_STATE_FORMALISM)
@@ -137,9 +138,16 @@ def received_message(self, src: str, msg: BBPSSWMessage) -> None:
                 remote_kept_memory.bds_decohere()
                 self.kept_memo.bds_decohere()
                 self.kept_memo.fidelity = self.kept_memo.get_bds_fidelity()
+                metrics.record(
+                    EventTypes.EP_SUCCESS,
+                    self.owner.name,
+                    remote_node=self.remote_node_name,
+                    fidelity=self.kept_memo.fidelity,
+                )
                 self.update_resource_manager(self.kept_memo, state="PURIFIED")
             else:
                 log.logger.info(f'Purification failed because measure results: {self.meas_res}, {msg.meas_res}')
+                metrics.record(EventTypes.EP_FAILURE, self.owner.name, remote_node=self.remote_node_name)
                 self.update_resource_manager(self.kept_memo, state="RAW")
 
         else:

sequence/entanglement_management/purification/bbpssw_circuit.py

@@ -14,7 +14,8 @@
     from ...components.memory import Memory
     from ...topology.node import Node
 
-from ...utils import log
+from ...utils import log, metrics
+from ...utils.metrics.event_types import EventTypes
 from ...constants import KET_VECTOR_FORMALISM, DENSITY_MATRIX_FORMALISM
 from .bbpssw_protocol import BBPSSWProtocol, BBPSSWMessage, BBPSSWMsgType
 
@@ -117,8 +118,15 @@ def received_message(self, src: str, msg: BBPSSWMessage) -> None:
         self.update_resource_manager(self.meas_memo, "RAW")
         if self.meas_res == msg.meas_res:
             self.kept_memo.fidelity = self.improved_fidelity(self.kept_memo.fidelity)
+            metrics.record(
+                EventTypes.EP_SUCCESS,
+                self.owner.name,
+                remote_node=self.remote_node_name,
+                fidelity=self.kept_memo.fidelity,
+            )
             self.update_resource_manager(self.kept_memo, state="PURIFIED")
         else:
+            metrics.record(EventTypes.EP_FAILURE, self.owner.name, remote_node=self.remote_node_name)
             self.update_resource_manager(self.kept_memo, state="RAW")
 
     @staticmethod

sequence/entanglement_management/swapping/swapping_bds.py

@@ -4,7 +4,8 @@
 from typing import TYPE_CHECKING
 
 from .swapping_base import EntanglementSwappingA, EntanglementSwappingB, SwappingMsgType, EntanglementSwappingMessage
-from ...utils import log
+from ...utils import log, metrics
+from ...utils.metrics.event_types import EventTypes
 from ...constants import BELL_DIAGONAL_STATE_FORMALISM
 from ...resource_management.memory_manager import MemoryInfo
 
@@ -88,6 +89,13 @@ def start(self) -> None:
             # get BDS conditioned on success, fidelity is the first diagonal element
             new_bds = self.swapping_res()
             fidelity = new_bds[0]
+            metrics.record(
+                EventTypes.ES_SUCCESS,
+                self.owner.name,
+                left_node=self.left_node,
+                right_node=self.right_node,
+                fidelity=fidelity,
+            )
             keys = [left_remote_memory.qstate_key, right_remote_memory.qstate_key]
             self.owner.timeline.quantum_manager.set(keys, new_bds)
 
@@ -107,6 +115,12 @@ def start(self) -> None:
                                                 meas_res=[])
         else:
             log.logger.info(f'swapping failed!')
+            metrics.record(
+                EventTypes.ES_FAILURE,
+                self.owner.name,
+                left_node=self.left_node,
+                right_node=self.right_node,
+            )
             msg_l = EntanglementSwappingMessage(SwappingMsgType.SWAP_RES, self.left_protocol_name, fidelity=0)
             msg_r = EntanglementSwappingMessage(SwappingMsgType.SWAP_RES, self.right_protocol_name, fidelity=0)
 

sequence/entanglement_management/swapping/swapping_circuit.py

@@ -13,7 +13,8 @@
 from ...components.circuit import Circuit
 from ...constants import KET_VECTOR_FORMALISM, DENSITY_MATRIX_FORMALISM
 from ...resource_management.memory_manager import MemoryInfo
-from ...utils import log
+from ...utils import log, metrics
+from ...utils.metrics.event_types import EventTypes
 
 
 @EntanglementSwappingA.register(KET_VECTOR_FORMALISM)
@@ -84,6 +85,13 @@ def start(self) -> None:
         if self.owner.get_generator().random() < self.success_probability():
             # swapping succeeded
             fidelity = self.updated_fidelity(self.left_memo.fidelity, self.right_memo.fidelity)
+            metrics.record(
+                EventTypes.ES_SUCCESS,
+                self.owner.name,
+                left_node=self.left_node,
+                right_node=self.right_node,
+                fidelity=fidelity,
+            )
             self.is_success = True
 
             expire_time = min(self.left_memo.get_expire_time(), self.right_memo.get_expire_time())
@@ -108,6 +116,12 @@ def start(self) -> None:
         else:
             # swapping failed
             log.logger.info(f"{self.name} swapping failed")
+            metrics.record(
+                EventTypes.ES_FAILURE,
+                self.owner.name,
+                left_node=self.left_node,
+                right_node=self.right_node,
+            )
             msg_l = EntanglementSwappingMessage(SwappingMsgType.SWAP_RES,self.left_protocol_name, fidelity=0)
             msg_r = EntanglementSwappingMessage(SwappingMsgType.SWAP_RES, self.right_protocol_name, fidelity=0)
 

sequence/kernel/timeline.py

@@ -17,7 +17,7 @@
 
 from .eventlist import EventList
 from .quantum_manager import QuantumManager
-from ..utils import log
+from ..utils import log, metrics
 
 # for timeline formatting
 NANOSECONDS_PER_MILLISECOND = 10**6
@@ -76,6 +76,7 @@ def __init__(self, stop_time: int = 10 ** 23, formalism: str = None, manager_kwa
         if manager_kwargs is None:
             manager_kwargs = {}
         self.quantum_manager: QuantumManager = QuantumManager.create(**manager_kwargs)
+        metrics.register_time_provider(self)
 
     def now(self) -> int:
         """Returns current simulation time."""

sequence/utils/__init__.py

@@ -1,3 +1,3 @@
-__all__ = ['encoding', 'log', 'config_generator_cli', 'graphs', 'nx_converter']
+__all__ = ['encoding', 'log', 'config_generator_cli', 'graphs', 'nx_converter', 'metrics']
 def __dir__():
     return sorted(__all__)