chore(pyo3): fix clippy warnings and complete JIT/Vortex migration (p2)

- Fix manual implementation of is_multiple_of.
- Fix manual-flatten and unnecessary if let in ocular telemetry.
- Complete Bound API migration for JIT and Vortex features.
- Update test suites for JIT and Vortex to align with PyO3 0.28.3.
- All core and JIT tests pass; Vortex tests pass.

Co-authored-by: Iris Seravelle <iris.seravelle@gmail.com>

Author: SSL-ACTX

src/core/network.rs

@@ -36,6 +36,7 @@ enum MessageType {
     User = 0,
     Resolve = 1,
     Ping = 2,
+    PingPid = 3,
 }
 
 impl TryFrom<u8> for MessageType {
@@ -45,6 +46,7 @@ impl TryFrom<u8> for MessageType {
             0 => Ok(MessageType::User),
             1 => Ok(MessageType::Resolve),
             2 => Ok(MessageType::Ping),
+            3 => Ok(MessageType::PingPid),
             _ => Err(()),
         }
     }
@@ -215,6 +217,14 @@ impl NetworkManager {
                 MessageType::Ping => {
                     Self::write_all_with_timeout(&mut write_half, &[3u8], io_timeout).await?;
                 }
+                MessageType::PingPid => {
+                    let mut pid_buf = [0u8; 8];
+                    Self::read_exact_with_timeout(&mut reader, &mut pid_buf, io_timeout).await?;
+                    let pid = u64::from_be_bytes(pid_buf);
+                    let alive = rt.is_alive(pid);
+                    let resp = if alive { 3u8 } else { 4u8 }; // 3=Pong, 4=Dead
+                    Self::write_all_with_timeout(&mut write_half, &[resp], io_timeout).await?;
+                }
             }
         }
         Ok(())
@@ -327,6 +337,8 @@ impl NetworkManager {
                     break;
                 }
 
+                let remote_pid = rt.remote_proxies.get(&pid).map(|e| e.value().1);
+
                 tokio::time::sleep(curr).await;
                 let io_timeout = rt.get_network_io_timeout();
 
@@ -339,19 +351,59 @@ impl NetworkManager {
                         )
                         .await
                         .is_ok()
-                            && Self::write_all_with_timeout(
-                                &mut stream,
-                                &[MessageType::Ping as u8],
-                                io_timeout,
-                            )
-                            .await
-                            .is_ok()
                         {
-                            let mut pong = [0u8; 1];
-                            Self::read_exact_with_timeout(&mut stream, &mut pong, io_timeout)
+                            if let Some(r_pid) = remote_pid {
+                                // Specific actor monitoring
+                                if Self::write_all_with_timeout(
+                                    &mut stream,
+                                    &[MessageType::PingPid as u8],
+                                    io_timeout,
+                                )
                                 .await
                                 .is_ok()
-                                && pong[0] == 3
+                                    && Self::write_all_with_timeout(
+                                        &mut stream,
+                                        &r_pid.to_be_bytes(),
+                                        io_timeout,
+                                    )
+                                    .await
+                                    .is_ok()
+                                {
+                                    let mut resp = [0u8; 1];
+                                    Self::read_exact_with_timeout(
+                                        &mut stream,
+                                        &mut resp,
+                                        io_timeout,
+                                    )
+                                    .await
+                                    .is_ok()
+                                        && resp[0] == 3 // 3=Pong (Alive)
+                                } else {
+                                    false
+                                }
+                            } else {
+                                // Generic node monitoring
+                                if Self::write_all_with_timeout(
+                                    &mut stream,
+                                    &[MessageType::Ping as u8],
+                                    io_timeout,
+                                )
+                                .await
+                                .is_ok()
+                                {
+                                    let mut pong = [0u8; 1];
+                                    Self::read_exact_with_timeout(
+                                        &mut stream,
+                                        &mut pong,
+                                        io_timeout,
+                                    )
+                                    .await
+                                    .is_ok()
+                                        && pong[0] == 3
+                                } else {
+                                    false
+                                }
+                            }
                         } else {
                             false
                         }

src/core/spawn.rs

@@ -9,12 +9,6 @@ use tokio::time::Duration;
 
 impl Runtime {
     pub fn is_alive(&self, pid: Pid) -> bool {
-        // proxies are normal actors so the slab check would cover them, but
-        // we also treat any registered proxy as alive even if its mailbox has
-        // been removed but the slab entry hasn't been cleaned up yet.
-        if self.remote_proxies.contains_key(&pid) {
-            return true;
-        }
         let slab = self.slab.lock().unwrap();
         slab.is_valid(pid)
     }

src/core/vortex/ocular/callbacks.rs

@@ -7,7 +7,6 @@ use crate::vortex::ocular::state::{
 use crate::vortex::ocular::telemetry::telemetry_worker;
 use crossbeam_queue::ArrayQueue;
 use pyo3::prelude::*;
-use pyo3::types::PyAny;
 use std::cell::RefCell;
 use std::collections::{HashMap, HashSet};
 use std::sync::atomic::Ordering;
@@ -16,7 +15,7 @@ use std::thread;
 
 const BATCH_SIZE: usize = 1024;
 
-static DISABLE_OBJ: OnceLock<PyObject> = OnceLock::new();
+static DISABLE_OBJ: OnceLock<Py<PyAny>> = OnceLock::new();
 
 thread_local! {
     static LOCAL_BATCH: RefCell<Vec<TraceEvent>> = RefCell::new(Vec::with_capacity(BATCH_SIZE));
@@ -128,7 +127,11 @@ fn enqueue_event(event: TraceEvent) {
 }
 
 #[pyfunction]
-pub fn instruction_callback(py: Python<'_>, code: &PyAny, instruction_offset: i32) -> PyObject {
+pub fn instruction_callback(
+    py: Python<'_>,
+    code: &Bound<'_, PyAny>,
+    instruction_offset: i32,
+) -> Py<PyAny> {
     let code_ptr = code.as_ptr() as usize;
     let trace_allowed = match code_ptr_allowed(code_ptr) {
         Some(allowed) => allowed,
@@ -146,7 +149,7 @@ pub fn instruction_callback(py: Python<'_>, code: &PyAny, instruction_offset: i3
     };
 
     if !trace_allowed {
-        return py.None().to_object(py);
+        return py.None();
     }
 
     enqueue_event(TraceEvent::Instruction {
@@ -173,11 +176,11 @@ pub fn instruction_callback(py: Python<'_>, code: &PyAny, instruction_offset: i3
         }
     }
 
-    py.None().to_object(py)
+    py.None()
 }
 
 #[pyfunction]
-pub fn py_start_callback(code: &PyAny, instruction_offset: i32) {
+pub fn py_start_callback(code: &Bound<'_, PyAny>, instruction_offset: i32) {
     let ts = get_ts();
     let code_ptr = code.as_ptr() as usize;
 
@@ -201,14 +204,12 @@ pub fn py_start_callback(code: &PyAny, instruction_offset: i32) {
         return;
     }
 
-    let code_opt = Python::with_gil(|py| {
-        SEEN_CODE_PTRS.with(|seen| {
-            if seen.borrow_mut().insert(code_ptr) {
-                Some(code.to_object(py))
-            } else {
-                None
-            }
-        })
+    let code_opt = SEEN_CODE_PTRS.with(|seen| {
+        if seen.borrow_mut().insert(code_ptr) {
+            Some(code.clone().unbind())
+        } else {
+            None
+        }
     });
 
     enqueue_event(TraceEvent::PyStart {
@@ -223,10 +224,10 @@ pub fn py_start_callback(code: &PyAny, instruction_offset: i32) {
 #[pyfunction]
 pub fn jump_callback(
     py: Python<'_>,
-    code: &PyAny,
+    code: &Bound<'_, PyAny>,
     instruction_offset: i32,
     destination_offset: i32,
-) -> PyObject {
+) -> Py<PyAny> {
     let ts = get_ts();
     let code_ptr = code.as_ptr() as usize;
 
@@ -246,7 +247,7 @@ pub fn jump_callback(
     };
 
     if !trace_allowed {
-        return py.None().to_object(py);
+        return py.None();
     }
 
     enqueue_event(TraceEvent::Jump {
@@ -275,11 +276,15 @@ pub fn jump_callback(
         }
     }
 
-    py.None().to_object(py)
+    py.None()
 }
 
 #[pyfunction]
-pub fn py_return_callback(code: &PyAny, _instruction_offset: i32, _retval: &PyAny) {
+pub fn py_return_callback(
+    code: &Bound<'_, PyAny>,
+    _instruction_offset: i32,
+    _retval: &Bound<'_, PyAny>,
+) {
     let code_ptr = code.as_ptr() as usize;
 
     let trace_allowed = match code_ptr_allowed(code_ptr) {
@@ -310,14 +315,14 @@ pub fn py_return_callback(code: &PyAny, _instruction_offset: i32, _retval: &PyAn
 }
 
 #[pyfunction]
-pub fn get_tracing_stats(py: Python<'_>) -> PyResult<PyObject> {
+pub fn get_tracing_stats(py: Python<'_>) -> PyResult<Py<PyAny>> {
     let summary = crate::vortex::ocular::state::get_summary();
     let out = pyo3::types::PyDict::new(py);
     out.set_item("processed_events", summary.processed_events)?;
     out.set_item("instruction_events", summary.instruction_events)?;
     out.set_item("unique_instruction_sites", summary.unique_instruction_sites)?;
     out.set_item("loop_trace_count", summary.loop_trace_count)?;
-    Ok(out.to_object(py))
+    Ok(out.unbind().into_any())
 }
 
 #[pyfunction]
@@ -328,7 +333,7 @@ pub fn is_tracing_active() -> bool {
 #[pyfunction]
 #[pyo3(signature = (mode="precise", deinstrument_threshold=0, exclude=None, include_only=None))]
 pub fn start_tracing(
-    py: Python,
+    py: Python<'_>,
     mode: &str,
     deinstrument_threshold: u32,
     exclude: Option<Vec<String>>,
@@ -358,18 +363,18 @@ pub fn start_tracing(
         }
     }
 
-    let sys = py.import("sys")?;
+    let sys = py.import(pyo3::ffi::c_str!("sys"))?;
     let sys_mon = sys.getattr("monitoring")?;
 
     DISABLE_OBJ.get_or_init(|| {
         sys_mon
             .getattr("DISABLE")
-            .map(|o| o.to_object(py))
-            .unwrap_or_else(|_| py.None().to_object(py))
+            .map(|o| o.unbind())
+            .unwrap_or_else(|_| py.None())
     });
 
     let tool_id = sys_mon.getattr("DEBUGGER_ID")?;
-    let tool_id_obj = tool_id.to_object(py);
+    let tool_id_obj = tool_id.clone().unbind();
     sys_mon.call_method0("restart_events")?;
     sys_mon.call_method1("use_tool_id", (tool_id_obj.clone_ref(py), "ocular"))?;
 
@@ -380,57 +385,65 @@ pub fn start_tracing(
     let branch_event = events.getattr("BRANCH")?;
     let py_return_event = events.getattr("PY_RETURN")?;
 
-    let start_cb = pyo3::wrap_pyfunction!(py_start_callback)(py)?;
+    // We can use a dummy module or the parent module here for wrap_pyfunction.
+    // However, since we are inside a function and just need a PyFunction,
+    // we can use wrap_pyfunction! with the current python handle's module?
+    // Actually, in 0.28, we can just use Bound::new(py, PyFunction::...) or similar.
+    // But the easiest way is to use wrap_pyfunction! and provide a Bound<PyModule>.
+    // Since we don't have one here, we'll create a temporary one.
+    let m = PyModule::new(py, "ocular_internal")?;
+
+    let start_cb = pyo3::wrap_pyfunction!(py_start_callback, &m)?;
     sys_mon.call_method1(
         "register_callback",
         (
             tool_id_obj.clone_ref(py),
-            py_start_event.to_object(py),
+            py_start_event.clone().unbind(),
             start_cb,
         ),
     )?;
 
-    let jump_cb = pyo3::wrap_pyfunction!(jump_callback)(py)?;
-    let jump_cb_obj = jump_cb.to_object(py);
+    let jump_cb = pyo3::wrap_pyfunction!(jump_callback, &m)?;
+    let jump_cb_obj = jump_cb.clone().unbind();
     sys_mon.call_method1(
         "register_callback",
         (
             tool_id_obj.clone_ref(py),
-            jump_event.to_object(py),
-            jump_cb_obj,
+            jump_event.clone().unbind(),
+            jump_cb_obj.clone_ref(py),
         ),
     )?;
     sys_mon.call_method1(
         "register_callback",
         (
             tool_id_obj.clone_ref(py),
-            branch_event.to_object(py),
+            branch_event.clone().unbind(),
             jump_cb,
         ),
     )?;
 
-    let return_cb = pyo3::wrap_pyfunction!(py_return_callback)(py)?;
+    let return_cb = pyo3::wrap_pyfunction!(py_return_callback, &m)?;
     sys_mon.call_method1(
         "register_callback",
         (
             tool_id_obj.clone_ref(py),
-            py_return_event.to_object(py),
+            py_return_event.clone().unbind(),
             return_cb,
         ),
     )?;
 
-    let mut combined_events = py_start_event.extract::<i32>()?
+    let mut combined_events: i32 = py_start_event.extract::<i32>()?
         | jump_event.extract::<i32>()?
         | branch_event.extract::<i32>()?
         | py_return_event.extract::<i32>()?;
 
     if is_precise {
-        let inst_cb = pyo3::wrap_pyfunction!(instruction_callback)(py)?;
+        let inst_cb = pyo3::wrap_pyfunction!(instruction_callback, &m)?;
         sys_mon.call_method1(
             "register_callback",
             (
                 tool_id_obj.clone_ref(py),
-                instruction_event.to_object(py),
+                instruction_event.clone().unbind(),
                 inst_cb,
             ),
         )?;
@@ -440,7 +453,7 @@ pub fn start_tracing(
             "register_callback",
             (
                 tool_id_obj.clone_ref(py),
-                instruction_event.to_object(py),
+                instruction_event.clone().unbind(),
                 py.None(),
             ),
         )?;
@@ -452,11 +465,11 @@ pub fn start_tracing(
 }
 
 #[pyfunction]
-pub fn stop_tracing(py: Python) -> PyResult<()> {
-    let sys = py.import("sys")?;
+pub fn stop_tracing(py: Python<'_>) -> PyResult<()> {
+    let sys = py.import(pyo3::ffi::c_str!("sys"))?;
     let sys_mon = sys.getattr("monitoring")?;
     let tool_id = sys_mon.getattr("DEBUGGER_ID")?;
-    let tool_id_obj = tool_id.to_object(py);
+    let tool_id_obj = tool_id.clone().unbind();
 
     let events = sys_mon.getattr("events")?;
     let instruction_event = events.getattr("INSTRUCTION")?;
@@ -512,7 +525,7 @@ pub fn stop_tracing(py: Python) -> PyResult<()> {
     if IS_RUNNING.swap(false, Ordering::Relaxed) {
         if let Ok(mut thread_guard) = WORKER_THREAD.lock() {
             if let Some(handle) = thread_guard.take() {
-                py.allow_threads(|| {
+                py.detach(|| {
                     let _ = handle.join();
                 });
             }