CSY/reowolf Changeset - 090935e00933 · Centrum Wiskunde & Informatica (CWI)

Changeset - 090935e00933

Parent rev.

Child rev.

[Not reviewed]

0 5 0

MH - 4 years ago 2021-12-03 15:48:54
contact@maxhenger.nl

Remove debug logging

5 files changed with 2 insertions and 96 deletions:

src/protocol/parser/pass_tokenizer.rs

src/runtime/connector.rs

src/runtime/consensus.rs

src/runtime/mod.rs

src/runtime/scheduler.rs

0 comments (0 inline, 0 general)

src/protocol/parser/pass_tokenizer.rs

➞

Show inline comments

@@ @@ -783,80 +783,6 @@ fn maybe_number_remaining(c: u8) -> bool { @@
     // Note: hex range includes the possible binary indicator 'b' and 'B';
     return
         (c == b'o' || c == b'O' || c == b'x' || c == b'X') ||
             (c >= b'0' && c <= b'9') || (c >= b'A' && c <= b'F') || (c >= b'a' && c <= b'f') ||
             c == b'_';
+}
 #[cfg(test)]
 mod tests {
     use super::*;
     // TODO: Remove at some point
     #[test]
     fn test_tokenizer() {
         let mut source = InputSource::new_test("
         #version 500
         # hello 2
         import std.reo::*;
         struct Thing {
             int a: 5,
+        }
         enum Hello {
             A,
+            B
+        }
         // Hello hello, is it me you are looking for?
         // I can seee it in your eeeyes
         func something(int a, int b, int c) -> byte {
             int a = 5;
             struct Inner {
                 int a
+            }
             struct City {
                 int b
+            }
             /* Waza
             How are you doing
             Things in here yo
             /* */ */
             a = a + 5 * 2;
             struct Pressure {
                 int d
+            }
+        }
         ");
         let mut t = PassTokenizer::new();
         let mut buffer = TokenBuffer::new();
         t.tokenize(&mut source, &mut buffer).expect("tokenize");
         println!("Ranges:\n");
         for (idx, range) in buffer.ranges.iter().enumerate() {
             println!("[{}] {:?}", idx, range)
+        }
         println!("Tokens:\n");
         let mut iter = buffer.tokens.iter().enumerate();
         while let Some((idx, token)) = iter.next() {
             match token.kind {
                 TokenKind::Ident | TokenKind::Pragma | TokenKind::Integer |
                 TokenKind::String | TokenKind::Character | TokenKind::LineComment |
                 TokenKind::BlockComment => {
                     let (_, end) = iter.next().unwrap();
                     println!("[{}] {:?} ......", idx, token.kind);
                     assert_eq!(end.kind, TokenKind::SpanEnd);
                     let text = source.section_at_pos(token.pos, end.pos);
                     println!("{}", String::from_utf8_lossy(text));
                 },
                 _ => {
                     println!("[{}] {:?}", idx, token.kind);
+                }
+            }
+        }
+    }
+}
@@ \ No newline at end of file @@

src/runtime/connector.rs

➞

Show inline comments

@@ @@ -242,13 +242,12 @@ impl ConnectorPDL { @@
             // And prepare the branch for running
             self.tree.push_into_queue(QueueKind::Runnable, receiving_branch_id);
+        }
+    }
     pub fn handle_new_sync_comp_message(&mut self, message: SyncCompMessage, ctx: &mut ComponentCtx) -> Option<ConnectorScheduling> {
         println!("DEBUG: Actually really handling {:?}", message);
         if let Some(round_conclusion) = self.consensus.handle_new_sync_comp_message(message, ctx) {
             return Some(self.enter_non_sync_mode(round_conclusion, ctx));
+        }
         return None;
+    }
@@ @@ -409,15 +408,13 @@ impl ConnectorPDL { @@
                             &pd.modules, &pd.heap,
                             String::from("attempted to 'put' on port that is no longer owned")
                         );
                         self.eval_error = Some(eval_error);
                         self.mode = Mode::SyncError;
                         println!("DEBUGERINO: Notify of fatal branch");
                         if let Some(conclusion) = self.consensus.notify_of_fatal_branch(branch_id, comp_ctx) {
                             println!("DEBUGERINO: Actually got {:?}", conclusion);
                             return self.enter_non_sync_mode(conclusion, comp_ctx);
+                        }
+                    }
+                }
             },
             _ => unreachable!("unexpected run result {:?} in sync mode", run_result),

src/runtime/consensus.rs

➞

Show inline comments

@@ @@ -169,13 +169,12 @@ impl Consensus { @@
         debug_assert!(self.is_in_sync());
         // Check for trivial case, where branch has not yet communicated within
         // the consensus algorithm
         let branch = &self.branch_annotations[failed_branch_id.index as usize];
         if branch.channel_mapping.iter().all(|v| v.registered_id.is_none()) {
             println!("DEBUG: Failure everything silent");
             return Some(RoundConclusion::Failure);
+        }
         // We're not in the trivial case: since we've communicated we need to
         // let everyone know that this round is probably not going to end well.
         return self.initiate_sync_failure(ctx);
@@ @@ -299,13 +298,12 @@ impl Consensus { @@
         // TODO: Handle sending and receiving ports
         // Set final ports
         let _branch = &self.branch_annotations[branch_id.index as usize];
         // Clear out internal storage to defaults
         println!("DEBUG: ***** Incrementing sync round stuff");
         self.highest_connector_id = ConnectorId::new_invalid();
         self.branch_annotations.clear();
         self.branch_markers.clear();
         self.encountered_ports.clear();
         self.solution_combiner.clear();
         self.handled_wave = false;
@@ @@ -316,14 +314,12 @@ impl Consensus { @@
         self.sync_round += 1;
         for peer in self.peers.iter_mut() {
             peer.encountered_this_round = false;
             peer.expected_sync_round += 1;
+        }
         println!("DEBUG: ***** Peers post round are:\n{:#?}", &self.peers)
+    }
     // --- Handling messages
     /// Prepares a message for sending. Caller should have made sure that
     /// sending the message is consistent with the speculative state.
@@ @@ -429,13 +425,12 @@ impl Consensus { @@
                     .find(|(component_id, _, _)| *component_id == ctx.id)
                     .unwrap();
                 return Some(RoundConclusion::Success(*branch_id));
             },
             SyncCompContent::GlobalFailure => {
                 // Global failure of round, send Ack to leader
                 println!("DEBUGERINO: Got GlobalFailure, sending Ack in response");
                 debug_assert_ne!(self.highest_connector_id, ctx.id); // not the leader
                 let _result = self.send_to_leader_or_handle_as_leader(SyncCompContent::AckFailure, ctx);
                 debug_assert!(_result.is_none());
                 return Some(RoundConclusion::Failure);
             },
             SyncCompContent::Notification => {
@@ @@ -588,13 +583,12 @@ impl Consensus { @@
     // --- Internal helpers
     fn handle_received_sync_header(&mut self, sync_header: SyncHeader, ctx: &mut ComponentCtx) -> MessageOrigin {
         debug_assert!(sync_header.sending_component_id != ctx.id); // not sending to ourselves
         let origin = self.handle_peer(&sync_header);
         println!(" ********************** GOT {:?}", origin);
         if origin != MessageOrigin::Present {
             // We do not have to handle it now
             return origin;
+        }
         if sync_header.highest_component_id > self.highest_connector_id {
@@ @@ -806,13 +800,12 @@ impl Consensus { @@
                         ctx.submit_message(Message::SyncComp(message)).unwrap();
+                    }
+                }
+            }
+        }
         println!("DEBUGERINO: Leader entering error state, we need to wait on {:?}", encountered.iter().map(|v| v.index).collect::<Vec<_>>());
         self.conclusion = Some(RoundConclusion::Failure);
         if encountered.is_empty() {
             // We don't have to wait on Acks
             return Some(RoundConclusion::Failure);
         } else {
             self.ack_remaining = encountered.len() as u32;
@@ @@ -842,13 +835,12 @@ impl Consensus { @@
             // Someone (or us) has already initiated a sync failure.
             return maybe_already;
+        }
         let maybe_conclusion = self.send_to_leader_or_handle_as_leader(SyncCompContent::LocalFailure, ctx);
         debug_assert!(if maybe_already.is_some() { maybe_conclusion.is_some() } else { true });
         println!("DEBUG: Maybe conclusion is {:?}", maybe_conclusion);
         // Initiate a discovery wave so peers can do the same
         self.handled_wave = true;
         for mapping in &self.branch_annotations[0].channel_mapping {
             let channel_id = mapping.channel_id;
             let port_info = ctx.get_port_by_channel_id(channel_id).unwrap();
@@ @@ -1222,14 +1214,12 @@ impl SolutionCombiner { @@
                     id: entry.channel_id,
                     state: if entry.is_closed { PresenceState::Closed } else { PresenceState::OnePresent },
                 });
+            }
+        }
         println!("DEBUGGERINO Presence is now:\n{:#?}", self.presence);
         return self.check_for_global_failure();
+    }
     fn mark_failure_and_check_for_global_failure(&mut self) -> bool {
         self.failure_reported = true;
         return self.check_for_global_failure();
@@ @@ -1470,17 +1460,15 @@ impl SolutionCombiner { @@
+                    }
+                }
+            }
+        }
         // Handle channel presence
         println!("DEBUGERINO: Presence before joining is {:#?}", &self.presence);
         if self.presence.is_empty() {
             // Trivial case
             self.presence = combiner.presence;
             println!("DEBUGERINO: Trivial merging")
         } else {
             for presence in combiner.presence {
                 match self.presence.iter_mut().find(|v| v.id == presence.id) {
                     Some(entry) => {
                         // Combine entries. Take first that has Closed, then
                         // check first that has both, then check if they are
@@ @@ -1506,17 +1494,15 @@ impl SolutionCombiner { @@
                     },
                     None => {
                         self.presence.push(presence);
+                    }
+                }
+            }
             println!("DEBUGERINO: Presence after joining is {:#?}", &self.presence);
             // After adding everything we might have immediately found a solution
             if self.check_for_global_failure() {
                 println!("DEBUG: Returning immediate failure?");
                 return Some(LeaderConclusion::Failure);
+            }
+        }
         return None;
+    }

src/runtime/mod.rs

➞

Show inline comments

@@ @@ -589,13 +589,12 @@ impl ConnectorStore { @@
                 let generation = target.generation.load(Ordering::Acquire);
                 key = ConnectorKey{ index: index as u32, generation };
                 target.connector.ctx.id = key.downcast();
+            }
+        }
         println!("DEBUG [ global store  ] Created component at {}", key.index);
         return key;
+    }
     /// Destroys a connector. Caller should make sure it is not scheduled for
     /// execution. Otherwise one experiences "bad stuff" (tm).
     fn destroy(&mut self, key: ConnectorKey) {
@@ @@ -603,13 +602,12 @@ impl ConnectorStore { @@
             let target = self.entries.get_mut(key.index as usize);
             (**target).generation.fetch_add(1, Ordering::SeqCst);
             std::ptr::drop_in_place(*target);
             // Note: but not deallocating!
+        }
         println!("DEBUG [ global store  ] Destroyed component at {}", key.index);
         self.free.push(key.index as usize);
+    }
+}
 impl Drop for ConnectorStore {
     fn drop(&mut self) {

src/runtime/scheduler.rs

➞

Show inline comments

@@ @@ -408,17 +408,17 @@ impl Scheduler { @@
                 self.runtime.push_work(connector_key)
+            }
+        }
+    }
     fn debug(&self, message: &str) {
         println!("DEBUG [thrd:{:02} conn:  ]: {}", self.scheduler_id, message);
+        // println!("DEBUG [thrd:{:02} conn:  ]: {}", self.scheduler_id, message);
+    }
     fn debug_conn(&self, conn: ConnectorId, message: &str) {
         println!("DEBUG [thrd:{:02} conn:{:02}]: {}", self.scheduler_id, conn.index, message);
+        // println!("DEBUG [thrd:{:02} conn:{:02}]: {}", self.scheduler_id, conn.index, message);
+    }
+}
 // -----------------------------------------------------------------------------
 // ComponentCtx
 // -----------------------------------------------------------------------------
@@ @@ -540,13 +540,12 @@ impl ComponentCtx { @@
                     port_info.state == PortState::Open
                 },
                 None => false,
             };
             if !is_valid {
                 // We don't own the port
                 println!(" ****** DEBUG ****** : Sending through closed port!!! {}", port_id.index);
                 return Err(());
+            }
+        }
         self.outbox.push_back(contents);
         return Ok(());

0 comments (0 inline, 0 general)