Put ActorError's fields in Box (#1469)

Summary:
Pull Request resolved: #1469

As title. Same motivation as D82982701.

Reviewed By: pablorfb-meta

Differential Revision: D84162324

fbshipit-source-id: ca3d85cdb5acc5936019176bb458f93c1f1af910

Author: pzhan9

hyperactor/src/actor.rs

@@ -310,8 +310,8 @@ where
 /// with the ID of the actor being served.
 #[derive(Debug)]
 pub struct ActorError {
-    pub(crate) actor_id: ActorId,
-    pub(crate) kind: ActorErrorKind,
+    pub(crate) actor_id: Box<ActorId>,
+    pub(crate) kind: Box<ActorErrorKind>,
 }
 
 /// The kinds of actor serving errors.
@@ -362,14 +362,17 @@ pub enum ActorErrorKind {
 
 impl ActorError {
     /// Create a new actor server error with the provided id and kind.
-    pub(crate) fn new(actor_id: ActorId, kind: ActorErrorKind) -> Self {
-        Self { actor_id, kind }
+    pub(crate) fn new(actor_id: &ActorId, kind: ActorErrorKind) -> Self {
+        Self {
+            actor_id: Box::new(actor_id.clone()),
+            kind: Box::new(kind),
+        }
     }
 
     /// Passthrough this error.
     fn passthrough(&self) -> Self {
         ActorError::new(
-            self.actor_id.clone(),
+            &self.actor_id,
             ActorErrorKind::Passthrough(anyhow::anyhow!("{}", self.kind)),
         )
     }
@@ -390,25 +393,28 @@ impl std::error::Error for ActorError {
 
 impl From<MailboxError> for ActorError {
     fn from(inner: MailboxError) -> Self {
-        Self::new(inner.actor_id().clone(), ActorErrorKind::from(inner))
+        Self {
+            actor_id: Box::new(inner.actor_id().clone()),
+            kind: Box::new(ActorErrorKind::from(inner)),
+        }
     }
 }
 
 impl From<MailboxSenderError> for ActorError {
     fn from(inner: MailboxSenderError) -> Self {
-        Self::new(
-            inner.location().actor_id().clone(),
-            ActorErrorKind::from(inner),
-        )
+        Self {
+            actor_id: Box::new(inner.location().actor_id().clone()),
+            kind: Box::new(ActorErrorKind::from(inner)),
+        }
     }
 }
 
 impl From<ActorSupervisionEvent> for ActorError {
     fn from(inner: ActorSupervisionEvent) -> Self {
-        Self::new(
-            inner.actor_id.clone(),
-            ActorErrorKind::UnhandledSupervisionEvent(inner),
-        )
+        Self {
+            actor_id: Box::new(inner.actor_id.clone()),
+            kind: Box::new(ActorErrorKind::UnhandledSupervisionEvent(inner)),
+        }
     }
 }
 
@@ -609,7 +615,6 @@ impl<A: Actor> ActorHandle<A> {
     }
 
     /// Signal the actor to drain its current messages and then stop.
-    #[allow(clippy::result_large_err)] // TODO: Consider reducing the size of `ActorError`.
     pub fn drain_and_stop(&self) -> Result<(), ActorError> {
         tracing::info!("ActorHandle::drain_and_stop called: {}", self.actor_id());
         self.cell.signal(Signal::DrainAndStop)

hyperactor/src/lib.rs

@@ -57,6 +57,7 @@
 #![feature(anonymous_lifetime_in_impl_trait)]
 #![feature(assert_matches)]
 #![feature(associated_type_defaults)]
+#![feature(box_patterns)]
 #![feature(btree_cursors)]
 #![feature(const_type_id)]
 #![feature(error_reporter)]

hyperactor/src/proc.rs

@@ -1006,7 +1006,6 @@ impl<A: Actor> Instance<A> {
     }
 
     /// Signal the actor to stop.
-    #[allow(clippy::result_large_err)] // TODO: Consider reducing the size of `ActorError`.
     pub fn stop(&self) -> Result<(), ActorError> {
         tracing::info!("Instance::stop called, {}", self.cell.actor_id());
         self.cell.signal(Signal::DrainAndStop)
@@ -1033,7 +1032,6 @@ impl<A: Actor> Instance<A> {
     }
 
     /// Send a message to the actor itself with a delay usually to trigger some event.
-    #[allow(clippy::result_large_err)] // TODO: Consider reducing the size of `ActorError`.
     pub fn self_message_with_delay<M>(&self, message: M, delay: Duration) -> Result<(), ActorError>
     where
         M: Message,
@@ -1096,7 +1094,7 @@ impl<A: Actor> Instance<A> {
         let (actor_status, event) = match result {
             Ok(_) => (ActorStatus::Stopped, None),
             Err(ActorError {
-                kind: ActorErrorKind::UnhandledSupervisionEvent(event),
+                kind: box ActorErrorKind::UnhandledSupervisionEvent(event),
                 ..
             }) => (event.actor_status.clone(), Some(event)),
             Err(err) => (
@@ -1167,7 +1165,7 @@ impl<A: Actor> Instance<A> {
                 let backtrace = panic_handler::take_panic_backtrace()
                     .unwrap_or_else(|e| format!("Cannot take backtrace due to: {:?}", e));
                 Err(ActorError::new(
-                    self.self_id().clone(),
+                    self.self_id(),
                     ActorErrorKind::Panic(anyhow::anyhow!("{}\n{}", err_msg, backtrace)),
                 ))
             }
@@ -1221,7 +1219,7 @@ impl<A: Actor> Instance<A> {
         actor
             .init(self)
             .await
-            .map_err(|err| ActorError::new(self.self_id().clone(), ActorErrorKind::Init(err)))?;
+            .map_err(|err| ActorError::new(self.self_id(), ActorErrorKind::Init(err)))?;
         let need_drain;
         'messages: loop {
             self.change_status(ActorStatus::Idle);
@@ -1237,7 +1235,7 @@ impl<A: Actor> Instance<A> {
                         for supervision_event in supervision_event_receiver.drain() {
                             self.handle_supervision_event(actor, supervision_event).await?;
                         }
-                        return Err(ActorError::new(self.self_id().clone(), ActorErrorKind::Processing(err)));
+                        return Err(ActorError::new(self.self_id(), ActorErrorKind::Processing(err)));
                     }
                 }
                 signal = signal_receiver.recv() => {
@@ -1269,7 +1267,7 @@ impl<A: Actor> Instance<A> {
             while let Ok(work) = work_rx.try_recv() {
                 if let Err(err) = work.handle(actor, self).await {
                     return Err(ActorError::new(
-                        self.self_id().clone(),
+                        self.self_id(),
                         ActorErrorKind::Processing(err),
                     ));
                 }
@@ -1664,7 +1662,6 @@ impl InstanceCell {
     }
 
     /// Send a signal to the actor.
-    #[allow(clippy::result_large_err)] // TODO: Consider reducing the size of `ActorError`.
     pub fn signal(&self, signal: Signal) -> Result<(), ActorError> {
         if let Some((signal_port, _)) = &self.inner.actor_loop {
             signal_port.send(signal).map_err(ActorError::from)

hyperactor_multiprocess/src/system_actor.rs

@@ -570,7 +570,6 @@ impl World {
         world_id.name().starts_with(SHADOW_PREFIX)
     }
 
-    #[allow(clippy::result_large_err)] // TODO: Consider reducing the size of `CastError`.
     fn get_port_ref_from_host(
         &self,
         host_id: &HostId,
@@ -584,7 +583,6 @@ impl World {
     }
 
     /// Adds procs to the world.
-    #[allow(clippy::result_large_err)] // TODO: Consider reducing the size of `SystemActorError`.
     fn add_proc(
         &mut self,
         proc_id: ProcId,
@@ -654,7 +652,6 @@ impl World {
         Ok(())
     }
 
-    #[allow(clippy::result_large_err)] // TODO: Consider reducing the size of `SystemActorError`.
     fn get_hosts_to_procs(&mut self) -> Result<HashMap<HostId, Vec<ProcId>>, SystemActorError> {
         // A map from host ID to scheduled proc IDs on this host.
         let mut host_proc_map: HashMap<HostId, Vec<ProcId>> = HashMap::new();