refactor: generalize event jumping for db/rr

Author: alehander92

src/db-backend/src/db.rs

@@ -14,8 +14,8 @@ use runtime_tracing::{
 use crate::distinct_vec::DistinctVec;
 use crate::expr_loader::ExprLoader;
 use crate::lang::Lang;
-use crate::replay::{Events, Replay};
-use crate::task::{Action, Breakpoint, Call, CallArg, CoreTrace, Location, ProgramEvent, RRTicks, NO_INDEX, NO_PATH, NO_POSITION, CtLoadLocalsArguments, VariableWithRecord};
+use crate::replay::Replay;
+use crate::task::{Action, Breakpoint, Call, CallArg, CoreTrace, Events, Location, ProgramEvent, RRTicks, NO_INDEX, NO_PATH, NO_POSITION, CtLoadLocalsArguments, VariableWithRecord};
 use crate::value::{Type, Value, ValueRecordWithType};
 
 const NEXT_INTERNAL_STEP_OVERS_LIMIT: usize = 1_000;
@@ -1128,6 +1128,13 @@ impl Replay for DbReplay {
         self.load_location(&mut expr_loader)
     }
 
+    fn event_jump(&mut self, event: &ProgramEvent) -> Result<bool, Box<dyn Error>> {
+        let step_id = StepId(event.direct_location_rr_ticks); // currently using this field
+                                                            // for compat with rr/gdb core support    
+        self.jump_to(step_id)?;
+        Ok(true)
+    }
+
     fn current_step_id(&mut self) -> StepId {
         self.step_id
     }

src/db-backend/src/handler.rs

@@ -640,9 +640,7 @@ impl Handler {
     }
 
     pub fn event_jump(&mut self, _req: dap::Request, event: ProgramEvent) -> Result<(), Box<dyn Error>> {
-        let step_id = StepId(event.direct_location_rr_ticks); // currently using this field
-                                                              // for compat with rr/gdb core support
-        self.replay.jump_to(step_id)?;
+        let _ = self.replay.event_jump(&event)?;
         self.step_id = self.replay.current_step_id();
         self.complete_move(false)?;
 

src/db-backend/src/query.rs

@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 
-use crate::task::{Action, Breakpoint, CtLoadLocalsArguments, Location};
+use crate::task::{Action, Breakpoint, CtLoadLocalsArguments, Location, ProgramEvent};
 use crate::lang::Lang;
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -17,4 +17,6 @@ pub enum CtRRQuery {
     DeleteBreakpoints,
     ToggleBreakpoint { breakpoint: Breakpoint },
     JumpToCall { location: Location },
+    LoadAllEvents,
+    EventJump { program_event: ProgramEvent },
 }

src/db-backend/src/replay.rs

@@ -4,17 +4,9 @@ use std::error::Error;
 use crate::db::DbRecordEvent;
 use crate::expr_loader::ExprLoader;
 use crate::lang::Lang;
-use crate::task::{Action, Breakpoint, Location, ProgramEvent, CtLoadLocalsArguments, VariableWithRecord};
+use crate::task::{Action, Breakpoint, Events, Location, CtLoadLocalsArguments, ProgramEvent, VariableWithRecord};
 use crate::value::ValueRecordWithType;
 
-
-#[derive(Debug, Clone)]
-pub struct Events {
-    pub events: Vec<ProgramEvent>,
-    pub first_events: Vec<ProgramEvent>,
-    pub contents: String,
-}
-
 pub trait Replay: std::fmt::Debug {
     fn load_location(&mut self, expr_loader: &mut ExprLoader) -> Result<Location, Box<dyn Error>>;
     fn run_to_entry(&mut self) -> Result<(), Box<dyn Error>>;
@@ -34,5 +26,6 @@ pub trait Replay: std::fmt::Debug {
     fn delete_breakpoints(&mut self) -> Result<bool, Box<dyn Error>>;
     fn toggle_breakpoint(&mut self, breakpoint: &Breakpoint) -> Result<Breakpoint, Box<dyn Error>>;
     fn jump_to_call(&mut self, location: &Location) -> Result<Location, Box<dyn Error>>;
+    fn event_jump(&mut self, event: &ProgramEvent) -> Result<bool, Box<dyn Error>>;
     fn current_step_id(&mut self) -> StepId;
 }

src/db-backend/src/rr_dispatcher.rs

@@ -8,16 +8,16 @@ use std::thread;
 use std::time::Duration;
 use std::ffi::OsStr;
 
-use log::{info, warn, error};
+use log::{info, error};
 use runtime_tracing::StepId;
 
 use crate::db::DbRecordEvent;
 use crate::expr_loader::ExprLoader;
 use crate::lang::Lang;
 use crate::paths::ct_rr_worker_socket_path;
 use crate::query::CtRRQuery;
-use crate::replay::{Events, Replay};
-use crate::task::{Action, Breakpoint, Location, CtLoadLocalsArguments, VariableWithRecord};
+use crate::replay::Replay;
+use crate::task::{Action, Breakpoint, Events, Location, CtLoadLocalsArguments, ProgramEvent, VariableWithRecord};
 use crate::value::ValueRecordWithType;
 
 #[derive(Debug)]
@@ -199,12 +199,13 @@ impl Replay for RRDispatcher {
 
     fn load_events(&mut self) -> Result<Events, Box<dyn Error>> {
         self.ensure_active_stable()?;
-        warn!("TODO load_events rr");
-        Ok(Events {
-            events: vec![],
-            first_events: vec![],
-            contents: "".to_string(),
-        })
+        let events = serde_json::from_str::<Events>(&self.stable.run_query(CtRRQuery::LoadAllEvents)?)?;
+        Ok(events)
+        // Ok(Events {
+        //     events: vec![],
+        //     first_events: vec![],
+        //     contents: "".to_string(),
+        // })
     }
 
     fn step(&mut self, action: Action, forward: bool) -> Result<bool, Box<dyn Error>> {
@@ -297,6 +298,15 @@ impl Replay for RRDispatcher {
         )?)
     }
 
+    fn event_jump(&mut self, event: &ProgramEvent) -> Result<bool, Box<dyn Error>> {
+        self.ensure_active_stable()?;
+        Ok(serde_json::from_str::<bool>(
+            &self.stable.run_query(
+                CtRRQuery::EventJump { program_event: event.clone() }
+            )?
+        )?)
+    }
+
     fn current_step_id(&mut self) -> StepId {
         // cache location or step_id and return
         // OR always load from worker

src/db-backend/src/task.rs

@@ -673,7 +673,7 @@ impl FlowUpdate {
     }
 }
 
-#[derive(Debug, Default, Clone, Serialize, Deserialize)]
+#[derive(Debug, Default, Clone, Serialize, Deserialize, JsonSchema)]
 #[serde(rename_all(serialize = "camelCase", deserialize = "camelCase"))]
 pub struct ProgramEvent {
     pub kind: EventLogKind,
@@ -1668,6 +1668,15 @@ pub enum TraceKind {
     RR,
 }
 
+#[derive(Debug, Default, Clone, Serialize, Deserialize, JsonSchema)]
+#[serde(rename_all(serialize = "camelCase", deserialize = "camelCase"))]
+pub struct Events {
+    pub events: Vec<ProgramEvent>,
+    pub first_events: Vec<ProgramEvent>,
+    pub contents: String,
+}
+
+
 pub static mut TASK_ID_MAP: &mut [usize] = &mut [0; 100];
 pub static mut EVENT_ID_MAP: &mut [usize] = &mut [0; 100];