Fixed async model mismatch between NetQASM and SimulaQron, make tests

now all passed

NetQASM uses Python generators, SimulaQron uses Twisted deferreds.
handle_netqasm_message was fixed to bridge the two. This caused previously
various weird errors including going into some infinite loop in which it
kept allocating qubits

Author: StephanieWehner

simulaqron/netqasm_backend/executioner.py

@@ -152,7 +152,7 @@ def cmd_new(self, physical_address):
             q = VirtualQubitRef(q_id, int(time.time()), virt)
             self.factory.qubitList[q_id] = q
             self._logger.info("Requested new physical qubit %d)", q_id)
-
+            print(f"DEBUG: Added qubit {q_id} to qubitList", flush=True)  # ADD THIS
         finally:
             self.factory._lock.release()
 

simulaqron/netqasm_backend/qnodeos.py

@@ -1,3 +1,7 @@
+import logging
+import os
+import sys
+
 from typing import Optional, Dict, Callable, Generator, Any, List, Type
 
 from netqasm.backend.executor import Executor
@@ -10,14 +14,28 @@
 from simulaqron.netqasm_backend.executioner import VanillaSimulaQronExecutioner
 from simulaqron.sdk.connection import (NewMessageType, GetQubitStateMessage,
                                        ReturnQubitStateMessage)
-
+from simulaqron.settings import simulaqron_settings
 
 class SubroutineHandler(QNodeController):
     def __init__(self, factory: "NetQASMFactory", instr_log_dir: Optional[str] = None,  # noqa: F821
                  flavour: Optional[Flavour] = None):
         super().__init__(factory.name, instr_log_dir=instr_log_dir, flavour=flavour)
 
         self.factory = factory
+        self._logger = logging.getLogger("QnodeController")
+        # logging that the user will later see on the screen
+        #stdout_file = open(f"/tmp/simulaqron-stdout-stderr-netqasmQ-{os.getpid()}.out.txt", "w")
+        #sys.stdout = stdout_file
+        #sys.stderr = stdout_file
+
+        # Force configure root logger with a handler, ensure our log output to this file
+        # will allow us to trace back exactly where it came from in the codebase
+        logging.basicConfig(
+            format="%(asctime)s:%(levelname)s:%(name)s:%(filename)s:%(lineno)d:%(message)s",
+            level=simulaqron_settings.log_level,
+            force=True,
+            stream=sys.stdout # send logs to the same file
+        )
 
         # Give a way for the executioner to return messages
         self._executor.add_return_msg_func(self._return_msg)
@@ -35,11 +53,52 @@ def protocol(self, protocol: Protocol):
 
     @inlineCallbacks
     def handle_netqasm_message(self, msg_id: int, msg: Message):
-        yield from super().handle_netqasm_message(
+        """
+        Handle incoming NetQASM messages by bridging two async models.
+    
+        NetQASM's executor uses Python generators (yield from) while SimulaQron
+        uses Twisted deferreds (@inlineCallbacks). This method bridges them by:
+        1. Running the parent's generator manually
+        2. Detecting whether each yielded item is a Twisted Deferred or a nested generator
+        3. For Deferreds: yielding to Twisted's reactor to await completion
+        4. For nested generators: consuming them fully and capturing their return value
+    
+        Without this bridge, nested generator return values (like physical_address
+        from _instr_qalloc) would be lost, causing None to propagate through the system.
+        This is also what caused the tests to fail, and probably other random weird things.
+        """
+        print(f"DEBUG handle_netqasm_message: msg_id={msg_id}", flush=True)
+        gen = super().handle_netqasm_message(
             msg_id=msg_id,
             msg=msg,
         )
 
+        # The following is a bug fix to properly wait for twisted deferreds
+      
+        try:
+            result = None
+            iteration = 0
+            while True:
+                iteration = iteration + 1
+                item = gen.send(result)
+                if hasattr(item, 'addCallback'):  # Deferred
+                    result = yield item
+                elif hasattr(item, '__next__'):  # Nested generator - consume it
+                    nested_result = None
+                    try:
+                        while True:
+                            nested_item = item.send(nested_result)
+                            if hasattr(nested_item, 'addCallback'):
+                                nested_result = yield nested_item
+                            else:
+                                nested_result = None
+                    except StopIteration as e:
+                        result = e.value  # Get the return value from the generator
+                else:
+                    result = None
+        except StopIteration:
+            pass
+
     def _handle_get_qubit_state(self, get_quibit_state_msg: GetQubitStateMessage) -> Generator[Any, None, None]:
         assert isinstance(self._executor, VanillaSimulaQronExecutioner)
         casted_executor: VanillaSimulaQronExecutioner = self._executor

simulaqron/start/start_qnodeos.py

@@ -16,7 +16,7 @@
 from simulaqron.general.host_config import SocketsConfig
 from simulaqron.settings import simulaqron_settings, network_config
 
-logger = logging.getLogger("start_vnode")
+logger = logging.getLogger("start_qnodeos")
 
 _RETRY_TIME = 0.1
 _TIMEOUT = 10
@@ -131,7 +131,7 @@ def start_qnodeos(node_name: str, network_name: str = "default", log_level: str
     # Force configure root logger with a handler
     logging.basicConfig(
         format="%(asctime)s:%(levelname)s:%(name)s:%(filename)s:%(lineno)d:%(message)s",
-        level=logging.DEBUG,
+        level=simulaqron_settings.log_level,
         force=True,
         stream=stdout_file  # send logs to the same file
     )

simulaqron/virtual_node/quantum.py

@@ -80,9 +80,7 @@ def __init__(self, node, register, simNum, num=0):
         self.T1 = settings.simulaqron_settings.t1
         self.last_accessed = time.time()
 
-        self._logger = get_netqasm_logger(
-            f"{self.__class__.__name__}(node={node.name}, sim_num={simNum})"
-        )
+        self._logger = logging.getLogger() 
 
     @inlineCallbacks
     def lock(self):

simulaqron/virtual_node/virtual.py

@@ -446,6 +446,7 @@ def remote_new_qubit(self, ignore_max_qubits=False):
         yield self._get_global_lock()
 
         try:
+            print(f"DEBUG new_qubit: len(virtQubits)={len(self.virtQubits)}, maxQubits={self.maxQubits}", flush=True)
             if (len(self.virtQubits) >= self.maxQubits) and (not ignore_max_qubits):
                 self._logger.error("Maximum number of virtual qubits reached.")
                 raise NoQubitError("Max virtual qubits reached")