diff --git a/src/runtime2/component/control_layer.rs b/src/runtime2/component/control_layer.rs
index 1d6a5a4de92b16371cefffbe3da16b8fae923855..2f1c4c9233fb8d9106189fe85002996382ee85e5 100644
--- a/src/runtime2/component/control_layer.rs
+++ b/src/runtime2/component/control_layer.rs
@@ -102,10 +102,10 @@ impl ControlLayer {
 
                 return AckAction::SendMessageAndAck(target_comp_id, message_to_send, to_ack);
             },
-            ControlContent::ScheduleComponent(content) => {
+            ControlContent::ScheduleComponent(to_schedule) => {
                 // If all change-of-peers are `Ack`d, then we're ready to
                 // schedule the component!
-                return AckAction::ScheduleComponent(content.to_schedule);
+                return AckAction::ScheduleComponent(*to_schedule);
             },
             ControlContent::BlockedPort(_) => unreachable!(),
             ControlContent::ClosedPort(port_id) => {
@@ -143,9 +143,7 @@ impl ControlLayer {
         self.entries.push(ControlEntry{
             id: entry_id,
             ack_countdown: 0, // incremented by calls to `add_reroute_entry`
-            content: ControlContent::ScheduleComponent(ContentScheduleComponent{
-                to_schedule: to_schedule_id
-            }),
+            content: ControlContent::ScheduleComponent(to_schedule_id),
         });
 
         return entry_id;
@@ -201,11 +199,13 @@ impl ControlLayer {
 
     pub(crate) fn mark_port_closed<'a>(&mut self, port_id: PortId, comp_ctx: &mut CompCtx) -> Option<(CompId, ControlMessage)> {
         let port = comp_ctx.get_port_mut(port_id);
+        let peer_port_id = port.peer_id;
+        let peer_comp_id = port.peer_comp_id;
         debug_assert!(port.state == PortState::Open || port.state == PortState::Blocked);
 
         port.state = PortState::Closed;
 
-        if port.peer_comp_id == comp_ctx.id {
+        if peer_comp_id == comp_ctx.id {
             // We own the other end of the channel as well
             return None;
         }
@@ -218,12 +218,12 @@ impl ControlLayer {
         });
 
         return Some((
-            port.peer_comp_id,
+            peer_comp_id,
             ControlMessage{
                 id: entry_id,
                 sender_comp_id: comp_ctx.id,
-                target_port_id: Some(port.peer_id),
-                content: ControlMessageContent::ClosePort(port.peer_id),
+                target_port_id: Some(peer_port_id),
+                content: ControlMessageContent::ClosePort(peer_port_id),
             }
         ));
     }
@@ -233,24 +233,24 @@ impl ControlLayer {
         //  be renamed. Lets see where the code ends up being
         let entry_id = self.take_id();
         let port_info = comp_ctx.get_port_mut(port_id);
+        let peer_port_id = port_info.peer_id;
+        let peer_comp_id = port_info.peer_comp_id;
         debug_assert_eq!(port_info.state, PortState::Open); // prevent unforeseen issues
         port_info.state = PortState::Blocked;
 
         self.entries.push(ControlEntry{
             id: entry_id,
             ack_countdown: 0,
-            content: ControlContent::BlockedPort(ContentBlockedPort{
-                blocked_port: port_id,
-            }),
+            content: ControlContent::BlockedPort(port_id),
         });
 
         return (
-            port_info.peer_comp_id,
+            peer_comp_id,
             ControlMessage{
                 id: entry_id,
                 sender_comp_id: comp_ctx.id,
-                target_port_id: Some(port_info.peer_id),
-                content: ControlMessageContent::BlockPort(port_info.peer_id),
+                target_port_id: Some(peer_port_id),
+                content: ControlMessageContent::BlockPort(peer_port_id),
             }
         );
     }
@@ -258,10 +258,10 @@ impl ControlLayer {
     pub(crate) fn mark_port_unblocked(&mut self, port_id: PortId, comp_ctx: &mut CompCtx) -> (CompId, ControlMessage) {
         // Find the entry that contains the blocking entry for the port
         let mut entry_index = usize::MAX;
-        let mut entry_id = ControlId::MAX;
+        let mut entry_id = ControlId::new_invalid();
         for (index, entry) in self.entries.iter().enumerate() {
-            if let ControlContent::BlockedPort(block_entry) = &entry.content {
-                if block_entry.blocked_port == port_id {
+            if let ControlContent::BlockedPort(blocked_port) = &entry.content {
+                if *blocked_port == port_id {
                     entry_index = index;
                     entry_id = entry.id;
                     break;
@@ -270,16 +270,18 @@ impl ControlLayer {
         }
 
         let port_info = comp_ctx.get_port_mut(port_id);
+        let peer_port_id = port_info.peer_id;
+        let peer_comp_id = port_info.peer_comp_id;
         debug_assert_eq!(port_info.state, PortState::Blocked);
         port_info.state = PortState::Open;
 
         return (
-            port_info.peer_comp_id,
+            peer_comp_id,
             ControlMessage{
                 id: entry_id,
                 sender_comp_id: comp_ctx.id,
-                target_port_id: Some(port_info.peer_id),
-                content: ControlMessageContent::UnblockPort(port_info.peer_id),
+                target_port_id: Some(peer_port_id),
+                content: ControlMessageContent::UnblockPort(peer_port_id),
             }
         )
     }