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

Changeset - a3a2b16408b1

Parent rev.

Child rev.

[Not reviewed]

0 14 1

mh - 3 years ago 2022-04-06 09:05:10
contact@maxhenger.nl

Initial polling thread implementation

15 files changed with 407 insertions and 100 deletions:

src/protocol/parser/token_parsing.rs

src/runtime2/communication.rs

src/runtime2/component/component.rs

src/runtime2/component/component_ip.rs

src/runtime2/component/component_pdl.rs

src/runtime2/component/consensus.rs

src/runtime2/component/mod.rs

src/runtime2/error.rs

src/runtime2/mod.rs

src/runtime2/poll/mod.rs

235

src/runtime2/runtime.rs

src/runtime2/scheduler.rs

src/runtime2/stdlib/internet.rs

src/runtime2/store/queue_mpsc.rs

src/runtime2/tests/mod.rs

0 comments (0 inline, 0 general)

src/protocol/parser/token_parsing.rs

➞

Show inline comments

 use crate::collections::ScopedSection;
 use crate::protocol::ast::*;
 use crate::protocol::input_source::{
     InputSource as InputSource,
     InputPosition as InputPosition,
     InputSpan,
     ParseError,
 };
 use super::tokens::*;
 use super::symbol_table::*;
 use super::{Module, PassCtx};
 // Keywords
 pub(crate) const KW_LET:       &'static [u8] = b"let";
 pub(crate) const KW_AS:        &'static [u8] = b"as";
 pub(crate) const KW_STRUCT:    &'static [u8] = b"struct";
 pub(crate) const KW_ENUM:      &'static [u8] = b"enum";
 pub(crate) const KW_UNION:     &'static [u8] = b"union";
 pub(crate) const KW_FUNCTION:  &'static [u8] = b"func";
 pub(crate) const KW_PRIMITIVE: &'static [u8] = b"primitive";
 pub(crate) const KW_COMPOSITE: &'static [u8] = b"composite";
 pub(crate) const KW_IMPORT:    &'static [u8] = b"import";
 // Keywords - literals
 pub(crate) const KW_LIT_TRUE:  &'static [u8] = b"true";
 pub(crate) const KW_LIT_FALSE: &'static [u8] = b"false";
 pub(crate) const KW_LIT_NULL:  &'static [u8] = b"null";
 // Keywords - function(like)s
 pub(crate) const KW_CAST:        &'static [u8] = b"cast";
 pub(crate) const KW_FUNC_GET:    &'static [u8] = b"get";
 pub(crate) const KW_FUNC_PUT:    &'static [u8] = b"put";
 pub(crate) const KW_FUNC_FIRES:  &'static [u8] = b"fires";
 pub(crate) const KW_FUNC_CREATE: &'static [u8] = b"create";
 pub(crate) const KW_FUNC_LENGTH: &'static [u8] = b"length";
 pub(crate) const KW_FUNC_ASSERT: &'static [u8] = b"assert";
 pub(crate) const KW_FUNC_PRINT:  &'static [u8] = b"print";
 // Keywords - statements
 pub(crate) const KW_STMT_CHANNEL:  &'static [u8] = b"channel";
 pub(crate) const KW_STMT_IF:       &'static [u8] = b"if";
 pub(crate) const KW_STMT_ELSE:     &'static [u8] = b"else";
 pub(crate) const KW_STMT_WHILE:    &'static [u8] = b"while";
 pub(crate) const KW_STMT_BREAK:    &'static [u8] = b"break";
 pub(crate) const KW_STMT_CONTINUE: &'static [u8] = b"continue";
 pub(crate) const KW_STMT_GOTO:     &'static [u8] = b"goto";
 pub(crate) const KW_STMT_RETURN:   &'static [u8] = b"return";
 pub(crate) const KW_STMT_SYNC:     &'static [u8] = b"sync";
 pub(crate) const KW_STMT_FORK:     &'static [u8] = b"fork";
 pub(crate) const KW_STMT_SELECT:   &'static [u8] = b"select";
 pub(crate) const KW_STMT_OR:       &'static [u8] = b"or";
 pub(crate) const KW_STMT_NEW:      &'static [u8] = b"new";
 // Keywords - types
 // Since types are needed for returning diagnostic information to the user, the
 // string variants are put here as well.
 pub(crate) const KW_TYPE_IN_PORT_STR:  &'static str = "in";
 pub(crate) const KW_TYPE_OUT_PORT_STR: &'static str = "out";
 pub(crate) const KW_TYPE_MESSAGE_STR:  &'static str = "msg";
 pub(crate) const KW_TYPE_BOOL_STR:     &'static str = "bool";
 pub(crate) const KW_TYPE_UINT8_STR:    &'static str = "u8";
 pub(crate) const KW_TYPE_UINT16_STR:   &'static str = "u16";
 pub(crate) const KW_TYPE_UINT32_STR:   &'static str = "u32";
 pub(crate) const KW_TYPE_UINT64_STR:   &'static str = "u64";
 pub(crate) const KW_TYPE_SINT8_STR:    &'static str = "s8";
 pub(crate) const KW_TYPE_SINT16_STR:   &'static str = "s16";
 pub(crate) const KW_TYPE_SINT32_STR:   &'static str = "s32";
 pub(crate) const KW_TYPE_SINT64_STR:   &'static str = "s64";
 pub(crate) const KW_TYPE_CHAR_STR:     &'static str = "char";
 pub(crate) const KW_TYPE_STRING_STR:   &'static str = "string";
 pub(crate) const KW_TYPE_INFERRED_STR: &'static str = "auto";
 pub(crate) const KW_TYPE_IN_PORT:  &'static [u8] = KW_TYPE_IN_PORT_STR.as_bytes();
 pub(crate) const KW_TYPE_OUT_PORT: &'static [u8] = KW_TYPE_OUT_PORT_STR.as_bytes();
 pub(crate) const KW_TYPE_MESSAGE:  &'static [u8] = KW_TYPE_MESSAGE_STR.as_bytes();
 pub(crate) const KW_TYPE_BOOL:     &'static [u8] = KW_TYPE_BOOL_STR.as_bytes();
 pub(crate) const KW_TYPE_UINT8:    &'static [u8] = KW_TYPE_UINT8_STR.as_bytes();
 pub(crate) const KW_TYPE_UINT16:   &'static [u8] = KW_TYPE_UINT16_STR.as_bytes();
 pub(crate) const KW_TYPE_UINT32:   &'static [u8] = KW_TYPE_UINT32_STR.as_bytes();
 pub(crate) const KW_TYPE_UINT64:   &'static [u8] = KW_TYPE_UINT64_STR.as_bytes();
 pub(crate) const KW_TYPE_SINT8:    &'static [u8] = KW_TYPE_SINT8_STR.as_bytes();
 pub(crate) const KW_TYPE_SINT16:   &'static [u8] = KW_TYPE_SINT16_STR.as_bytes();
 pub(crate) const KW_TYPE_SINT32:   &'static [u8] = KW_TYPE_SINT32_STR.as_bytes();
 pub(crate) const KW_TYPE_SINT64:   &'static [u8] = KW_TYPE_SINT64_STR.as_bytes();
 pub(crate) const KW_TYPE_CHAR:     &'static [u8] = KW_TYPE_CHAR_STR.as_bytes();
 pub(crate) const KW_TYPE_STRING:   &'static [u8] = KW_TYPE_STRING_STR.as_bytes();
 pub(crate) const KW_TYPE_INFERRED: &'static [u8] = KW_TYPE_INFERRED_STR.as_bytes();
 // Builtin pragma types
 // Not usable by the programmer, but usable in the standard library. These hint
 // at the fact that we need a different system (e.g. function overloading)
 pub(crate) const PRAGMA_TYPE_VOID: &'static [u8] = b"#type_void";
 pub(crate) const PRAGMA_TYPE_PORTLIKE: &'static [u8] = b"#type_portlike";
 pub(crate) const PRAGMA_TYPE_INTEGERLIKE: &'static [u8] = b"#type_integerlike";
 pub(crate) const PRAGMA_TYPE_ARRAYLIKE: &'static [u8] = b"#type_arraylike";
 /// A special trait for when consuming comma-separated things such that we can
 /// push them onto a `Vec` and onto a `ScopedSection`. As we monomorph for
 /// very specific comma-separated cases I don't expect polymorph bloat.
 /// Also, I really don't like this solution.
 pub(crate) trait Extendable {
     type Value;
     fn push(&mut self, v: Self::Value);
+}
 impl<T> Extendable for Vec<T> {
     type Value = T;
     #[inline]
     fn push(&mut self, v: Self::Value) {
         (self as &mut Vec<T>).push(v);
+    }
+}
 impl<T: Sized> Extendable for ScopedSection<T> {
     type Value = T;
     #[inline]
     fn push(&mut self, v: Self::Value) {
         (self as &mut ScopedSection<T>).push(v);
+    }
+}
 /// Consumes a domain-name identifier: identifiers separated by a dot. For
 /// simplification of later parsing and span identification the domain-name may
 /// contain whitespace, but must reside on the same line.
 pub(crate) fn consume_domain_ident<'a>(
     source: &'a InputSource, iter: &mut TokenIter
 ) -> Result<(&'a [u8], InputSpan), ParseError> {
     let (_, mut span) = consume_ident(source, iter)?;
     while let Some(TokenKind::Dot) = iter.next() {
         iter.consume();
         let (_, new_span) = consume_ident(source, iter)?;
         span.end = new_span.end;
+    }
     // Not strictly necessary, but probably a reasonable restriction: this
     // simplifies parsing of module naming and imports.
     if span.begin.line != span.end.line {
         return Err(ParseError::new_error_str_at_span(source, span, "module names may not span multiple lines"));
+    }
     // If module name consists of a single identifier, then it may not match any
     // of the reserved keywords
     let section = source.section_at_pos(span.begin, span.end);
     if is_reserved_keyword(section) {
         return Err(ParseError::new_error_str_at_span(source, span, "encountered reserved keyword"));
+    }
     Ok((source.section_at_pos(span.begin, span.end), span))
+}
 /// Consumes a specific expected token. Be careful to only call this with tokens
 /// that do not have a variable length.
 pub(crate) fn consume_token(source: &InputSource, iter: &mut TokenIter, expected: TokenKind) -> Result<InputSpan, ParseError> {
     if Some(expected) != iter.next() {
         return Err(ParseError::new_error_at_pos(
             source, iter.last_valid_pos(),
             format!("expected '{}'", expected.token_chars())
         ));
+    }
     let span = iter.next_span();
     iter.consume();
     Ok(span)
+}
 /// Consumes a comma separated list until the closing delimiter is encountered.
 /// The closing delimiter is consumed as well.
 pub(crate) fn consume_comma_separated_until<T, F, E>(
     close_delim: TokenKind, source: &InputSource, iter: &mut TokenIter, ctx: &mut PassCtx,
     mut consumer_fn: F, target: &mut E, item_name_and_article: &'static str,
     close_pos: Option<&mut InputPosition>
 ) -> Result<(), ParseError>
     where F: FnMut(&InputSource, &mut TokenIter, &mut PassCtx) -> Result<T, ParseError>,
           E: Extendable<Value=T>
+{
     let mut had_comma = true;
     let mut next;
     loop {
         next = iter.next();
         if Some(close_delim) == next {
             if let Some(close_pos) = close_pos {
                 // If requested return the position of the closing delimiter
                 let (_, new_close_pos) = iter.next_positions();
                 *close_pos = new_close_pos;
+            }
             iter.consume();
             break;
         } else if !had_comma || next.is_none() {
             return Err(ParseError::new_error_at_pos(
                 source, iter.last_valid_pos(),
                 format!("expected a '{}', or {}", close_delim.token_chars(), item_name_and_article)
             ));
+        }
         let new_item = consumer_fn(source, iter, ctx)?;
         target.push(new_item);
         next = iter.next();
         had_comma = next == Some(TokenKind::Comma);
         if had_comma {
             iter.consume();
+        }
+    }
     Ok(())
+}
 /// Consumes a comma-separated list of items if the opening delimiting token is
 /// encountered. If not, then the iterator will remain at its current position.
 /// Note that the potential cases may be:
 /// - No opening delimiter encountered, then we return `false`.
 /// - Both opening and closing delimiter encountered, but no items.
 /// - Opening and closing delimiter encountered, and items were processed.
 /// - Found an opening delimiter, but processing an item failed.
 pub(crate) fn maybe_consume_comma_separated<T, F, E>(
     open_delim: TokenKind, close_delim: TokenKind, source: &InputSource, iter: &mut TokenIter, ctx: &mut PassCtx,
     consumer_fn: F, target: &mut E, item_name_and_article: &'static str,
     close_pos: Option<&mut InputPosition>
 ) -> Result<bool, ParseError>
     where F: FnMut(&InputSource, &mut TokenIter, &mut PassCtx) -> Result<T, ParseError>,
           E: Extendable<Value=T>
+{
     if Some(open_delim) != iter.next() {
         return Ok(false);
+    }
     // Opening delimiter encountered, so must parse the comma-separated list.
     iter.consume();
     consume_comma_separated_until(close_delim, source, iter, ctx, consumer_fn, target, item_name_and_article, close_pos)?;
     Ok(true)
+}
 pub(crate) fn maybe_consume_comma_separated_spilled<F: FnMut(&InputSource, &mut TokenIter, &mut PassCtx) -> Result<(), ParseError>>(
     open_delim: TokenKind, close_delim: TokenKind, source: &InputSource,
     iter: &mut TokenIter, ctx: &mut PassCtx,
     mut consumer_fn: F, item_name_and_article: &'static str
 ) -> Result<bool, ParseError> {
     let mut next = iter.next();
     if Some(open_delim) != next {
         return Ok(false);
+    }
     iter.consume();
     let mut had_comma = true;
     loop {
         next = iter.next();
         if Some(close_delim) == next {
             iter.consume();
             break;
         } else if !had_comma {
             return Err(ParseError::new_error_at_pos(
                 source, iter.last_valid_pos(),
                 format!("expected a '{}', or {}", close_delim.token_chars(), item_name_and_article)
             ));
+        }
         consumer_fn(source, iter, ctx)?;
         next = iter.next();
         had_comma = next == Some(TokenKind::Comma);
         if had_comma {
             iter.consume();
+        }
+    }
     Ok(true)
+}
 /// Consumes a comma-separated list and expected the opening and closing
 /// characters to be present. The returned array may still be empty
 pub(crate) fn consume_comma_separated<T, F, E>(
     open_delim: TokenKind, close_delim: TokenKind, source: &InputSource,
     iter: &mut TokenIter, ctx: &mut PassCtx,
     consumer_fn: F, target: &mut E, item_name_and_article: &'static str,
     list_name_and_article: &'static str, close_pos: Option<&mut InputPosition>
 ) -> Result<(), ParseError>
     where F: FnMut(&InputSource, &mut TokenIter, &mut PassCtx) -> Result<T, ParseError>,
           E: Extendable<Value=T>
+{
     let first_pos = iter.last_valid_pos();
     match maybe_consume_comma_separated(
         open_delim, close_delim, source, iter, ctx, consumer_fn, target,
         item_name_and_article, close_pos
     ) {
         Ok(true) => Ok(()),
         Ok(false) => {
             return Err(ParseError::new_error_at_pos(
                 source, first_pos,
                 format!("expected {}", list_name_and_article)
             ));
         },
         Err(err) => Err(err)
+    }
+}
 /// Consumes an integer literal, may be binary, octal, hexadecimal or decimal,
 /// and may have separating '_'-characters.
 pub(crate) fn consume_integer_literal(source: &InputSource, iter: &mut TokenIter, buffer: &mut String) -> Result<(u64, InputSpan), ParseError> {
     if Some(TokenKind::Integer) != iter.next() {
         return Err(ParseError::new_error_str_at_pos(source, iter.last_valid_pos(), "expected an integer literal"));
+    }
     let integer_span = iter.next_span();
     iter.consume();
     let integer_text = source.section_at_span(integer_span);
     // Determine radix and offset from prefix
     let (radix, input_offset, radix_name) =
         if integer_text.starts_with(b"0b") || integer_text.starts_with(b"0B") {
             // Binary number
             (2, 2, "binary")
         } else if integer_text.starts_with(b"0o") || integer_text.starts_with(b"0O") {
             // Octal number
             (8, 2, "octal")
         } else if integer_text.starts_with(b"0x") || integer_text.starts_with(b"0X") {
             // Hexadecimal number
             (16, 2, "hexadecimal")
         } else {
             (10, 0, "decimal")
         };
     // Take out any of the separating '_' characters
     buffer.clear();
     for char_idx in input_offset..integer_text.len() {
         let char = integer_text[char_idx];
         if char == b'_' {
             continue;
+        }
         if !((char >= b'0' && char <= b'9') || (char >= b'A' && char <= b'F') || (char >= b'a' || char <= b'f')) {
             return Err(ParseError::new_error_at_span(
                 source, integer_span,
                 format!("incorrectly formatted {} number", radix_name)
             ));
+        }
         buffer.push(char::from(char));
+    }
     // Use the cleaned up string to convert to integer
     match u64::from_str_radix(&buffer, radix) {
         Ok(number) => Ok((number, integer_span)),
         Err(_) => Err(ParseError::new_error_at_span(
             source, integer_span,
             format!("incorrectly formatted {} number", radix_name)
         )),
+    }
+}
 /// Consumes a character literal. We currently support a limited number of
 /// backslash-escaped characters
 pub(crate) fn consume_character_literal(
     source: &InputSource, iter: &mut TokenIter
 ) -> Result<(char, InputSpan), ParseError> {
     if Some(TokenKind::Character) != iter.next() {
         return Err(ParseError::new_error_str_at_pos(source, iter.last_valid_pos(), "expected a character literal"));
+    }
     let span = iter.next_span();
     iter.consume();
     let char_text = source.section_at_span(span);
     if !char_text.is_ascii() {
         return Err(ParseError::new_error_str_at_span(
             source, span, "expected an ASCII character literal"
         ));
+    }
     debug_assert!(char_text.len() >= 2); // always includes the bounding "'"
     match char_text.len() {
 => return Err(ParseError::new_error_str_at_span(source, span, "too little characters in character literal")),
 => {
             // We already know the text is ascii, so just throw an error if we have the escape
             // character.
             if char_text[1] == b'\\' {
                 return Err(ParseError::new_error_str_at_span(source, span, "escape character without subsequent character"));
+            }
             return Ok((char_text[1] as char, span));
         },
 => {
             if char_text[1] == b'\\' {
                 let result = parse_escaped_character(source, span, char_text[2])?;
                 return Ok((result, span))
+            }
         },
         _ => {}
+    }
     return Err(ParseError::new_error_str_at_span(source, span, "too many characters in character literal"))
+}
 /// Consumes a string literal. We currently support a limited number of
 /// backslash-escaped characters. Note that the result is stored in the
 /// buffer.
 pub(crate) fn consume_string_literal(
     source: &InputSource, iter: &mut TokenIter, buffer: &mut String
 ) -> Result<InputSpan, ParseError> {
     if Some(TokenKind::String) != iter.next() {
         return Err(ParseError::new_error_str_at_pos(source, iter.last_valid_pos(), "expected a string literal"));
+    }
     buffer.clear();
     let span = iter.next_span();
     iter.consume();
     let text = source.section_at_span(span);
     if !text.is_ascii() {
         return Err(ParseError::new_error_str_at_span(source, span, "expected an ASCII string literal"));
+    }
     debug_assert_eq!(text[0], b'"'); // here as kind of a reminder: the span includes the bounding quotation marks
     debug_assert_eq!(text[text.len() - 1], b'"');
     buffer.reserve(text.len() - 2);
     let mut was_escape = false;
     for idx in 1..text.len() - 1 {
         let cur = text[idx];
         let is_escape = cur == b'\\';
         if was_escape {
             let to_push = parse_escaped_character(source, span, cur)?;
             buffer.push(to_push);
         } else {
             buffer.push(cur as char);
+        }
         if was_escape && is_escape {
             was_escape = false;
         } else {
             was_escape = is_escape;
+        }
+    }
     debug_assert!(!was_escape); // because otherwise we couldn't have ended the string literal
     Ok(span)
+}
 fn parse_escaped_character(source: &InputSource, literal_span: InputSpan, v: u8) -> Result<char, ParseError> {
     let result = match v {
         b'r' => '\r',
         b'n' => '\n',
         b't' => '\t',
         b'0' => '\0',
         b'\\' => '\\',
         b'\'' => '\'',
         b'"' => '"',
         v => {
             let msg = if v.is_ascii_graphic() {
                 format!("unsupported escape character '{}'", v as char)
             } else {
                 format!("unsupported escape character with (unsigned) byte value {}", v)
             };
             return Err(ParseError::new_error_at_span(source, literal_span, msg))
         },
     };
     Ok(result)
+}
 pub(crate) fn consume_pragma<'a>(source: &'a InputSource, iter: &mut TokenIter) -> Result<(&'a [u8], InputSpan), ParseError> {
     if Some(TokenKind::Pragma) != iter.next() {
         return Err(ParseError::new_error_str_at_pos(source, iter.last_valid_pos(), "expected a pragma"));
+    }
     let pragma_span = iter.next_span();
     iter.consume();
     Ok((source.section_at_span(pragma_span), pragma_span))
+}
 pub(crate) fn has_ident(source: &InputSource, iter: &mut TokenIter, expected: &[u8]) -> bool {
     peek_ident(source, iter).map_or(false, |section| section == expected)
+}
 pub(crate) fn peek_ident<'a>(source: &'a InputSource, iter: &mut TokenIter) -> Option<&'a [u8]> {
     if Some(TokenKind::Ident) == iter.next() {
         let (start, end) = iter.next_positions();
         return Some(source.section_at_pos(start, end))
+    }
     None
+}
 /// Consumes any identifier and returns it together with its span. Does not
 /// check if the identifier is a reserved keyword.
 pub(crate) fn consume_any_ident<'a>(
     source: &'a InputSource, iter: &mut TokenIter
 ) -> Result<(&'a [u8], InputSpan), ParseError> {
     if Some(TokenKind::Ident) != iter.next() {
         return Err(ParseError::new_error_str_at_pos(source, iter.last_valid_pos(), "expected an identifier"));
+    }
     let (ident_start, ident_end) = iter.next_positions();
     iter.consume();
     Ok((source.section_at_pos(ident_start, ident_end), InputSpan::from_positions(ident_start, ident_end)))
+}
 /// Consumes a specific identifier. May or may not be a reserved keyword.
 pub(crate) fn consume_exact_ident(source: &InputSource, iter: &mut TokenIter, expected: &[u8]) -> Result<InputSpan, ParseError> {
     let (ident, pos) = consume_any_ident(source, iter)?;
     if ident != expected {
         debug_assert!(expected.is_ascii());
         return Err(ParseError::new_error_at_pos(
             source, iter.last_valid_pos(),
             format!("expected the text '{}'", &String::from_utf8_lossy(expected))
         ));
+    }
     Ok(pos)
+}
 /// Consumes an identifier that is not a reserved keyword and returns it
 /// together with its span.
 pub(crate) fn consume_ident<'a>(
     source: &'a InputSource, iter: &mut TokenIter
 ) -> Result<(&'a [u8], InputSpan), ParseError> {
     let (ident, span) = consume_any_ident(source, iter)?;
     if is_reserved_keyword(ident) {
         return Err(ParseError::new_error_str_at_span(source, span, "encountered reserved keyword"));
+    }
     Ok((ident, span))
+}
 /// Consumes an identifier and immediately intern it into the `StringPool`
 pub(crate) fn consume_ident_interned(
     source: &InputSource, iter: &mut TokenIter, ctx: &mut PassCtx
 ) -> Result<Identifier, ParseError> {
     let (value, span) = consume_ident(source, iter)?;
     let value = ctx.pool.intern(value);
     Ok(Identifier{ span, value })
+}
 fn is_reserved_definition_keyword(text: &[u8]) -> bool {
     match text {
         KW_STRUCT | KW_ENUM | KW_UNION | KW_FUNCTION | KW_PRIMITIVE | KW_COMPOSITE => true,
         _ => false,
+    }
+}
 fn is_reserved_statement_keyword(text: &[u8]) -> bool {
     match text {
         KW_IMPORT | KW_AS |
         KW_STMT_CHANNEL | KW_STMT_IF | KW_STMT_WHILE |
         KW_STMT_BREAK | KW_STMT_CONTINUE | KW_STMT_GOTO | KW_STMT_RETURN |
         KW_STMT_SYNC | KW_STMT_FORK | KW_STMT_NEW => true,
         _ => false,
+    }
+}
 fn is_reserved_expression_keyword(text: &[u8]) -> bool {
     match text {
         KW_LET | KW_CAST |
         KW_LIT_TRUE | KW_LIT_FALSE | KW_LIT_NULL |
         // TODO: Remove this once global namespace errors work @nocommit
         // KW_FUNC_GET | KW_FUNC_PUT | KW_FUNC_FIRES | KW_FUNC_CREATE | KW_FUNC_ASSERT | KW_FUNC_LENGTH | KW_FUNC_PRINT => true,
         _ => false,
+    }
+}
 fn is_reserved_type_keyword(text: &[u8]) -> bool {
     match text {
         KW_TYPE_IN_PORT | KW_TYPE_OUT_PORT | KW_TYPE_MESSAGE | KW_TYPE_BOOL |
         KW_TYPE_UINT8 | KW_TYPE_UINT16 | KW_TYPE_UINT32 | KW_TYPE_UINT64 |
         KW_TYPE_SINT8 | KW_TYPE_SINT16 | KW_TYPE_SINT32 | KW_TYPE_SINT64 |
         KW_TYPE_CHAR | KW_TYPE_STRING |
         KW_TYPE_INFERRED => true,
         _ => false,
+    }
+}
 fn is_reserved_keyword(text: &[u8]) -> bool {
     return
         is_reserved_definition_keyword(text) ||
         is_reserved_statement_keyword(text) ||
         is_reserved_expression_keyword(text) ||
         is_reserved_type_keyword(text);
+}
 pub(crate) fn seek_module(modules: &[Module], root_id: RootId) -> Option<&Module> {
     for module in modules {
         if module.root_id == root_id {
             return Some(module)
+        }
+    }
     return None
+}
 /// Constructs a human-readable message indicating why there is a conflict of
 /// symbols.
 // Note: passing the `module_idx` is not strictly necessary, but will prevent
 // programmer mistakes during development: we get a conflict because we're
 // currently parsing a particular module.
 pub(crate) fn construct_symbol_conflict_error(
     modules: &[Module], module_idx: usize, ctx: &PassCtx, new_symbol: &Symbol, old_symbol: &Symbol
 ) -> ParseError {
     let module = &modules[module_idx];
     let get_symbol_span_and_msg = |symbol: &Symbol| -> (String, Option<InputSpan>) {
         match &symbol.variant {
             SymbolVariant::Module(module) => {
                 let import = &ctx.heap[module.introduced_at];
                 return (
                     format!("the module aliased as '{}' imported here", symbol.name.as_str()),
                     Some(import.as_module().span)
                 );
             },
             SymbolVariant::Definition(definition) => {
                 if definition.defined_in_module.is_invalid() {
                     // Must be a builtin thing
                     return (format!("the builtin '{}'", symbol.name.as_str()), None)
                 } else {
                     if let Some(import_id) = definition.imported_at {
                         let import = &ctx.heap[import_id];
                         return (
                             format!("the type '{}' imported here", symbol.name.as_str()),
                             Some(import.as_symbols().span)
                         );
                     } else if definition.defined_in_module == module.root_id {
                         // This is a symbol defined in the same module
                         return (
                             format!("the type '{}' defined here", symbol.name.as_str()),
                             Some(definition.identifier_span)
+                        )
                     } else {
                         // Not imported, not defined in the module, so must be
                         // a global
                         return (format!("the global '{}'", symbol.name.as_str()), None)
+                    }
+                }
+            }
+        }
     };
     let (new_symbol_msg, new_symbol_span) = get_symbol_span_and_msg(new_symbol);
     let (old_symbol_msg, old_symbol_span) = get_symbol_span_and_msg(old_symbol);
     let new_symbol_span = new_symbol_span.unwrap(); // because new symbols cannot be builtin
     match old_symbol_span {
         Some(old_symbol_span) => ParseError::new_error_at_span(
             &module.source, new_symbol_span, format!("symbol is defined twice: {}", new_symbol_msg)
         ).with_info_at_span(
             &module.source, old_symbol_span, format!("it conflicts with {}", old_symbol_msg)
         ),
         None => ParseError::new_error_at_span(
             &module.source, new_symbol_span,
             format!("symbol is defined twice: {} conflicts with {}", new_symbol_msg, old_symbol_msg)
+        )
+    }
+}
@@ \ No newline at end of file @@

src/runtime2/communication.rs

➞

Show inline comments

 use crate::protocol::eval::*;
 use super::runtime::*;
 use super::component::*;
 // -----------------------------------------------------------------------------
 // Generic types
 // -----------------------------------------------------------------------------
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub struct PortId(pub u32);
 impl PortId {
     /// This value is not significant, it is chosen to make debugging easier: a
     /// very large port number is more likely to shine a light on bugs.
     pub fn new_invalid() -> Self {
         return Self(u32::MAX);
+    }
+}
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub enum PortKind {
     Putter,
     Getter,
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum PortState {
     Open,
     BlockedDueToPeerChange,
     BlockedDueToFullBuffers,
     Closed,
+}
 impl PortState {
     pub fn is_blocked(&self) -> bool {
         match self {
             PortState::BlockedDueToPeerChange | PortState::BlockedDueToFullBuffers => true,
             PortState::Open | PortState::Closed => false,
+        }
+    }
+}
 pub struct Channel {
     pub putter_id: PortId,
     pub getter_id: PortId,
+}
 // -----------------------------------------------------------------------------
 // Data messages
 // -----------------------------------------------------------------------------
 #[derive(Debug)]
 pub struct DataMessage {
     pub data_header: MessageDataHeader,
     pub sync_header: MessageSyncHeader,
     pub content: ValueGroup,
+}
 #[derive(Debug)]
 pub enum PortAnnotationKind {
     Getter(PortAnnotationGetter),
     Putter(PortAnnotationPutter),
+}
 #[derive(Debug)]
 pub struct PortAnnotationGetter {
     pub self_comp_id: CompId,
     pub self_port_id: PortId,
     pub peer_comp_id: CompId,
     pub peer_port_id: PortId,
+}
 #[derive(Debug)]
 pub struct PortAnnotationPutter {
     pub self_comp_id: CompId,
     pub self_port_id: PortId,
+}
 #[derive(Debug)]
 pub struct MessageDataHeader {
     pub expected_mapping: Vec<(PortAnnotationKind, Option<u32>)>,
     pub new_mapping: u32,
     pub source_port: PortId,
     pub target_port: PortId,
+}
 // -----------------------------------------------------------------------------
 // Sync messages
 // -----------------------------------------------------------------------------
 #[derive(Debug)]
 pub struct SyncMessage {
     pub sync_header: MessageSyncHeader,
     pub content: SyncMessageContent,
+}
 #[derive(Debug)]
 pub enum SyncLocalSolutionEntry {
     Putter(SyncSolutionPutterPort),
     Getter(SyncSolutionGetterPort),
+}
 pub type SyncLocalSolution = Vec<SyncLocalSolutionEntry>;
 /// Getter port in a solution. Upon receiving a message it is certain about who
 /// its peer is.
 #[derive(Debug)]
 pub struct SyncSolutionGetterPort {
     pub self_comp_id: CompId,
     pub self_port_id: PortId,
     pub peer_comp_id: CompId,
     pub peer_port_id: PortId,
     pub mapping: u32,
+}
 /// Putter port in a solution. A putter may not be certain about who its peer
 /// component/port is.
 #[derive(Debug)]
 pub struct SyncSolutionPutterPort {
     pub self_comp_id: CompId,
     pub self_port_id: PortId,
     pub mapping: u32,
+}
 #[derive(Debug)]
 pub struct SyncSolutionChannel {
     pub putter: Option<SyncSolutionPutterPort>,
     pub getter: Option<SyncSolutionGetterPort>,
+}
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum SyncRoundDecision {
     None,
     Solution,
     Failure,
+}
 #[derive(Debug)]
 pub struct SyncPartialSolution {
     pub channel_mapping: Vec<SyncSolutionChannel>,
     pub decision: SyncRoundDecision,
+}
 impl Default for SyncPartialSolution {
     fn default() -> Self {
         return Self{
             channel_mapping: Vec::new(),
             decision: SyncRoundDecision::None,
+        }
+    }
+}
 #[derive(Debug)]
 pub enum SyncMessageContent {
     NotificationOfLeader,
     LocalSolution(CompId, SyncLocalSolution), // local solution of the specified component
     PartialSolution(SyncPartialSolution), // partial solution of multiple components
     GlobalSolution,
     GlobalFailure,
+}
 // -----------------------------------------------------------------------------
 // Control messages
 // -----------------------------------------------------------------------------
 #[derive(Debug)]
 pub struct ControlMessage {
     pub(crate) id: ControlId,
     pub sender_comp_id: CompId,
     pub target_port_id: Option<PortId>,
     pub content: ControlMessageContent,
+}
 #[derive(Copy, Clone, Debug)]
 pub enum ControlMessageContent {
     Ack,
     BlockPort(PortId),
     UnblockPort(PortId),
     ClosePort(PortId),
     PortPeerChangedBlock(PortId),
     PortPeerChangedUnblock(PortId, CompId),
+}
 // -----------------------------------------------------------------------------
 // Messages (generic)
 // -----------------------------------------------------------------------------
 #[derive(Debug)]
 pub struct MessageSyncHeader {
     pub sync_round: u32,
     pub sending_id: CompId,
     pub highest_id: CompId,
+}
 #[derive(Debug)]
 pub enum Message {
     Data(DataMessage),
     Sync(SyncMessage),
     Control(ControlMessage),
     Poll,
+}
 impl Message {
     pub(crate) fn target_port(&self) -> Option<PortId> {
         match self {
             Message::Data(v) =>
                 return Some(v.data_header.target_port),
             Message::Control(v) =>
                 return v.target_port_id,
             Message::Sync(_) =>
                 return None,
             Message::Poll =>
                 return None,
+        }
+    }
     pub(crate) fn modify_target_port(&mut self, port_id: PortId) {
         match self {
             Message::Data(v) =>
                 v.data_header.target_port = port_id,
             Message::Control(v) =>
                 v.target_port_id = Some(port_id),
             Message::Sync(_) => unreachable!(), // should never be called for this message type
             Message::Poll => unreachable!(),
+        }
+    }
+}

src/runtime2/component/component.rs

➞

Show inline comments

 use crate::protocol::eval::{Prompt, EvalError, ValueGroup, PortId as EvalPortId};
 use crate::protocol::*;
 use crate::runtime2::*;
 use crate::runtime2::communication::*;
 use super::{CompCtx, CompPDL};
 use super::component_context::*;
 use super::component_ip::*;
 use super::control_layer::*;
 use super::consensus::*;
 pub enum CompScheduling {
     Immediate,
     Requeue,
     Sleep,
     Exit,
+}
 /// Generic representation of a component (as viewed by a scheduler).
 pub(crate) trait Component {
     /// Called if the component is created by another component and the messages
     /// are being transferred between the two.
     fn adopt_message(&mut self, comp_ctx: &mut CompCtx, message: DataMessage);
     /// Called if the component receives a new message. The component is
     /// responsible for deciding where that messages goes.
     fn handle_message(&mut self, sched_ctx: &mut SchedulerCtx, comp_ctx: &mut CompCtx, message: Message);
     /// Called if the component's routine should be executed. The return value
     /// can be used to indicate when the routine should be run again.
     fn run(&mut self, sched_ctx: &mut SchedulerCtx, comp_ctx: &mut CompCtx) -> Result<CompScheduling, EvalError>;
+}
 /// Representation of the generic operating mode of a component.
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub(crate) enum CompMode {
     NonSync, // not in sync mode
     Sync, // in sync mode, can interact with other components
     SyncEnd, // awaiting a solution, i.e. encountered the end of the sync block
     BlockedGet, // blocked because we need to receive a message on a particular port
     BlockedPut, // component is blocked because the port is blocked
     BlockedSelect, // waiting on message to complete the select statement
     StartExit, // temporary state: if encountered then we start the shutdown process
     BusyExit, // temporary state: waiting for Acks for all the closed ports
     Exit, // exiting: shutdown process started, now waiting until the reference count drops to 0
+}
 impl CompMode {
     pub(crate) fn is_in_sync_block(&self) -> bool {
         use CompMode::*;
         match self {
             Sync | SyncEnd | BlockedGet | BlockedPut | BlockedSelect => true,
             NonSync | StartExit | BusyExit | Exit => false,
+        }
+    }
+}
 /// Component execution state: the execution mode along with some descriptive
 /// fields. Fields are public for ergonomic reasons, use member functions when
 /// appropriate.
 pub(crate) struct CompExecState {
     pub mode: CompMode,
     pub mode_port: PortId, // valid if blocked on a port (put/get)
     pub mode_value: ValueGroup, // valid if blocked on a put
+}
 impl CompExecState {
     pub(crate) fn new() -> Self {
         return Self{
             mode: CompMode::NonSync,
             mode_port: PortId::new_invalid(),
             mode_value: ValueGroup::default(),
+        }
+    }
     pub(crate) fn set_as_blocked_get(&mut self, port: PortId) {
         self.mode = CompMode::BlockedGet;
         self.mode_port = port;
         debug_assert!(self.mode_value.values.is_empty());
+    }
     pub(crate) fn is_blocked_on_get(&self, port: PortId) -> bool {
         return
             self.mode == CompMode::BlockedGet &&
             self.mode_port == port;
+    }
     pub(crate) fn set_as_blocked_put(&mut self, port: PortId, value: ValueGroup) {
         self.mode = CompMode::BlockedPut;
         self.mode_port = port;
         self.mode_value = value;
+    }
     pub(crate) fn is_blocked_on_put(&self, port: PortId) -> bool {
         return
             self.mode == CompMode::BlockedPut &&
             self.mode_port == port;
+    }
+}
 /// Creates a new component based on its definition. Meaning that if it is a
 /// user-defined component then we set up the PDL code state. Otherwise we
 /// construct a custom component. This does NOT take care of port and message
 /// management.
 pub(crate) fn create_component(
     protocol: &ProtocolDescription,
     definition_id: ProcedureDefinitionId, type_id: TypeId,
     arguments: ValueGroup, num_ports: usize
 ) -> Box<dyn Component> {
     let definition = &protocol.heap[definition_id];
     debug_assert!(definition.kind == ProcedureKind::Primitive || definition.kind == ProcedureKind::Composite);
     if definition.source.is_builtin() {
         // Builtin component
         let component = match definition.source {
             ProcedureSource::CompRandomU32 => Box::new(ComponentRandomU32::new(arguments)),
             _ => unreachable!(),
         };
         return component;
     } else {
         // User-defined component
         let prompt = Prompt::new(
             &protocol.types, &protocol.heap,
             definition_id, type_id, arguments
         );
         let component = CompPDL::new(prompt, num_ports);
         return Box::new(component);
+    }
+}
 // -----------------------------------------------------------------------------
 // Generic component messaging utilities (for sending and receiving)
 // -----------------------------------------------------------------------------
 /// Handles control messages in the default way. Note that this function may
 /// take a lot of actions in the name of the caller: pending messages may be
 /// sent, ports may become blocked/unblocked, etc. So the execution
 /// (`CompExecState`), control (`ControlLayer`) and consensus (`Consensus`)
 /// state may all change.
 pub(crate) fn default_handle_control_message(
     exec_state: &mut CompExecState, control: &mut ControlLayer, consensus: &mut Consensus,
     message: ControlMessage, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx
 ) {
     match message.content {
         ControlMessageContent::Ack => {
             default_handle_ack(control, message.id, sched_ctx, comp_ctx);
         },
         ControlMessageContent::BlockPort(port_id) => {
             // One of our messages was accepted, but the port should be
             // blocked.
             let port_handle = comp_ctx.get_port_handle(port_id);
             let port_info = comp_ctx.get_port(port_handle);
             debug_assert_eq!(port_info.kind, PortKind::Putter);
             if port_info.state == PortState::Open {
                 // only when open: we don't do this when closed, and we we don't do this if we're blocked due to peer changes
                 comp_ctx.set_port_state(port_handle, PortState::BlockedDueToFullBuffers);
+            }
         },
         ControlMessageContent::ClosePort(port_id) => {
             // Request to close the port. We immediately comply and remove
             // the component handle as well
             let port_handle = comp_ctx.get_port_handle(port_id);
             let peer_comp_id = comp_ctx.get_port(port_handle).peer_comp_id;
             let peer_handle = comp_ctx.get_peer_handle(peer_comp_id);
             // One exception to sending an `Ack` is if we just closed the
             // port ourselves, meaning that the `ClosePort` messages got
             // sent to one another.
             if let Some(control_id) = control.has_close_port_entry(port_handle, comp_ctx) {
                 default_handle_ack(control, control_id, sched_ctx, comp_ctx);
             } else {
                 default_send_ack(message.id, peer_handle, sched_ctx, comp_ctx);
                 comp_ctx.remove_peer(sched_ctx, port_handle, peer_comp_id, false); // do not remove if closed
                 comp_ctx.set_port_state(port_handle, PortState::Closed); // now set to closed
+            }
         },
         ControlMessageContent::UnblockPort(port_id) => {
             // We were previously blocked (or already closed)
             let port_handle = comp_ctx.get_port_handle(port_id);
             let port_info = comp_ctx.get_port(port_handle);
             debug_assert_eq!(port_info.kind, PortKind::Putter);
             if port_info.state == PortState::BlockedDueToFullBuffers {
                 default_handle_unblock_put(exec_state, consensus, port_handle, sched_ctx, comp_ctx);
+            }
         },
         ControlMessageContent::PortPeerChangedBlock(port_id) => {
             // The peer of our port has just changed. So we are asked to
             // temporarily block the port (while our original recipient is
             // potentially rerouting some of the in-flight messages) and
             // Ack. Then we wait for the `unblock` call.
             debug_assert_eq!(message.target_port_id, Some(port_id));
             let port_handle = comp_ctx.get_port_handle(port_id);
             comp_ctx.set_port_state(port_handle, PortState::BlockedDueToPeerChange);
             let port_info = comp_ctx.get_port(port_handle);
             let peer_handle = comp_ctx.get_peer_handle(port_info.peer_comp_id);
             default_send_ack(message.id, peer_handle, sched_ctx, comp_ctx);
         },
         ControlMessageContent::PortPeerChangedUnblock(new_port_id, new_comp_id) => {
             let port_handle = comp_ctx.get_port_handle(message.target_port_id.unwrap());
             let port_info = comp_ctx.get_port(port_handle);
             debug_assert!(port_info.state == PortState::BlockedDueToPeerChange);
             let old_peer_id = port_info.peer_comp_id;
             comp_ctx.remove_peer(sched_ctx, port_handle, old_peer_id, false);
             let port_info = comp_ctx.get_port_mut(port_handle);
             port_info.peer_comp_id = new_comp_id;
             port_info.peer_port_id = new_port_id;
             comp_ctx.add_peer(port_handle, sched_ctx, new_comp_id, None);
             default_handle_unblock_put(exec_state, consensus, port_handle, sched_ctx, comp_ctx);
+        }
+    }
+}
 /// Handles a component initiating the exiting procedure, and closing all of its
 /// ports. Should only be called once per component (which is ensured by
 /// checking and modifying the mode in the execution state).
 pub(crate) fn default_handle_start_exit(
     exec_state: &mut CompExecState, control: &mut ControlLayer,
     sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx
 ) -> CompScheduling {
     debug_assert_eq!(exec_state.mode, CompMode::StartExit);
     sched_ctx.log("Component starting exit");
     exec_state.mode = CompMode::BusyExit;
     // Iterating by index to work around borrowing rules
     for port_index in 0..comp_ctx.num_ports() {
         let port = comp_ctx.get_port_by_index_mut(port_index);
         if port.state == PortState::Closed {
             // Already closed, or in the process of being closed
             continue;
+        }
         // Mark as closed
         let port_id = port.self_id;
         port.state = PortState::Closed;
         // Notify peer of closing
         let port_handle = comp_ctx.get_port_handle(port_id);
         let (peer, message) = control.initiate_port_closing(port_handle, comp_ctx);
         let peer_info = comp_ctx.get_peer(peer);
         peer_info.handle.send_message(sched_ctx, Message::Control(message), true);
+        peer_info.handle.send_message(&sched_ctx.runtime, Message::Control(message), true);
+    }
     return CompScheduling::Immediate; // to check if we can shut down immediately
+}
 /// Handles a component waiting until all peers are notified that it is quitting
 /// (i.e. after calling `default_handle_start_exit`).
 pub(crate) fn default_handle_busy_exit(
     exec_state: &mut CompExecState, control: &ControlLayer,
     sched_ctx: &SchedulerCtx
 ) -> CompScheduling {
     debug_assert_eq!(exec_state.mode, CompMode::BusyExit);
     if control.has_acks_remaining() {
         sched_ctx.log("Component busy exiting, still has `Ack`s remaining");
         return CompScheduling::Sleep;
     } else {
         sched_ctx.log("Component busy exiting, now shutting down");
         exec_state.mode = CompMode::Exit;
         return CompScheduling::Exit;
+    }
+}
 #[inline]
 pub(crate) fn default_handle_exit(_exec_state: &CompExecState) -> CompScheduling {
     debug_assert_eq!(_exec_state.mode, CompMode::Exit);
     return CompScheduling::Exit;
+}
 // -----------------------------------------------------------------------------
 // Internal messaging/state utilities
 // -----------------------------------------------------------------------------
 /// Handles an `Ack` for the control layer.
 fn default_handle_ack(
     control: &mut ControlLayer, control_id: ControlId,
     sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx
 ) {
     // Since an `Ack` may cause another one, handle them in a loop
     let mut to_ack = control_id;
     loop {
         let (action, new_to_ack) = control.handle_ack(to_ack, sched_ctx, comp_ctx);
         match action {
             AckAction::SendMessage(target_comp, message) => {
                 // FIX @NoDirectHandle
                 let mut handle = sched_ctx.runtime.get_component_public(target_comp);
                 handle.send_message(sched_ctx, Message::Control(message), true);
+                handle.send_message(&sched_ctx.runtime, Message::Control(message), true);
                 let _should_remove = handle.decrement_users();
                 debug_assert!(_should_remove.is_none());
             },
             AckAction::ScheduleComponent(to_schedule) => {
                 // FIX @NoDirectHandle
                 let mut handle = sched_ctx.runtime.get_component_public(to_schedule);
                 // Note that the component is intentionally not
                 // sleeping, so we just wake it up
                 debug_assert!(!handle.sleeping.load(std::sync::atomic::Ordering::Acquire));
                 let key = unsafe { to_schedule.upgrade() };
                 sched_ctx.runtime.enqueue_work(key);
                 let _should_remove = handle.decrement_users();
                 debug_assert!(_should_remove.is_none());
             },
             AckAction::None => {}
+        }
         match new_to_ack {
             Some(new_to_ack) => to_ack = new_to_ack,
             None => break,
+        }
+    }
+}
 /// Little helper for sending the most common kind of `Ack`
 fn default_send_ack(
     causer_of_ack_id: ControlId, peer_handle: LocalPeerHandle,
     sched_ctx: &SchedulerCtx, comp_ctx: &CompCtx
 ) {
     let peer_info = comp_ctx.get_peer(peer_handle);
     peer_info.handle.send_message(sched_ctx, Message::Control(ControlMessage{
+    peer_info.handle.send_message(&sched_ctx.runtime, Message::Control(ControlMessage{
         id: causer_of_ack_id,
         sender_comp_id: comp_ctx.id,
         target_port_id: None,
         content: ControlMessageContent::Ack
     }), true);
+}
 /// Handles the unblocking of a putter port. In case there is a pending message
 /// on that port then it will be sent.
 fn default_handle_unblock_put(
     exec_state: &mut CompExecState, consensus: &mut Consensus,
     port_handle: LocalPortHandle, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx,
 ) {
     let port_info = comp_ctx.get_port_mut(port_handle);
     let port_id = port_info.self_id;
     debug_assert!(port_info.state.is_blocked());
     port_info.state = PortState::Open;
     if exec_state.is_blocked_on_put(port_id) {
         // Annotate the message that we're going to send
         let port_info = comp_ctx.get_port(port_handle); // for immutable access
         debug_assert_eq!(port_info.kind, PortKind::Putter);
         let to_send = exec_state.mode_value.take();
         let to_send = consensus.annotate_data_message(comp_ctx, port_info, to_send);
         // Retrieve peer to send the message
         let peer_handle = comp_ctx.get_peer_handle(port_info.peer_comp_id);
         let peer_info = comp_ctx.get_peer(peer_handle);
         peer_info.handle.send_message(sched_ctx, Message::Data(to_send), true);
+        peer_info.handle.send_message(&sched_ctx.runtime, Message::Data(to_send), true);
         exec_state.mode = CompMode::Sync; // because we're blocked on a `put`, we must've started in the sync state.
         exec_state.mode_port = PortId::new_invalid();
+    }
+}
 #[inline]
 pub(crate) fn port_id_from_eval(port_id: EvalPortId) -> PortId {
     return PortId(port_id.id);
+}
 #[inline]
 pub(crate) fn port_id_to_eval(port_id: PortId) -> EvalPortId {
     return EvalPortId{ id: port_id.0 };
+}

src/runtime2/component/component_ip.rs

➞

Show inline comments

 use rand::prelude as random;
 use rand::RngCore;
 use crate::protocol::eval::{ValueGroup, Value, EvalError};
 use crate::runtime2::*;
 use super::*;
 use super::component::{self, Component, CompExecState, CompScheduling, CompMode};
 use super::control_layer::*;
 use super::consensus::*;
 /// TODO: Temporary component to figure out what to do with custom components.
 ///     This component sends random numbers between two u32 limits
 pub struct ComponentRandomU32 {
     // Properties for this specific component
     output_port_id: PortId,
     random_minimum: u32,
     random_maximum: u32,
     num_sends: u32,
     max_num_sends: u32,
     generator: random::ThreadRng,
     // Generic state-tracking
     exec_state: CompExecState,
     did_perform_send: bool, // when in sync mode
     control: ControlLayer,
     consensus: Consensus,
+}
 impl Component for ComponentRandomU32 {
     fn adopt_message(&mut self, _comp_ctx: &mut CompCtx, _message: DataMessage) {
         // Impossible since this component does not have any input ports in its
         // signature.
         unreachable!();
+    }
     fn handle_message(&mut self, sched_ctx: &mut SchedulerCtx, comp_ctx: &mut CompCtx, message: Message) {
         match message {
             Message::Data(_message) => unreachable!(),
             Message::Sync(message) => {
                 let decision = self.consensus.receive_sync_message(sched_ctx, comp_ctx, message);
                 self.handle_sync_decision(sched_ctx, comp_ctx, decision);
             },
             Message::Control(message) => {
                 component::default_handle_control_message(
                     &mut self.exec_state, &mut self.control, &mut self.consensus,
                     message, sched_ctx, comp_ctx
                 );
+            }
             },
             Message::Poll => unreachable!(),
+        }
+    }
     fn run(&mut self, sched_ctx: &mut SchedulerCtx, comp_ctx: &mut CompCtx) -> Result<CompScheduling, EvalError> {
         sched_ctx.log(&format!("Running component ComponentRandomU32 (mode: {:?})", self.exec_state.mode));
         match self.exec_state.mode {
             CompMode::BlockedGet | CompMode::BlockedSelect => {
                 // impossible for this component, no input ports and no select
                 // blocks
                 unreachable!();
+            }
             CompMode::NonSync => {
                 // If in non-sync mode then we check if the arguments make sense
                 // (at some point in the future, this is just a testing
                 // component).
                 if self.random_minimum >= self.random_maximum {
                     // Could throw an evaluation error, but lets just panic
                     panic!("going to crash 'n burn your system now, please provide valid arguments");
+                }
                 if self.num_sends >= self.max_num_sends {
                     self.exec_state.mode = CompMode::StartExit;
                 } else {
                     sched_ctx.log("Entering sync mode");
                     self.did_perform_send = false;
                     self.consensus.notify_sync_start(comp_ctx);
                     self.exec_state.mode = CompMode::Sync;
+                }
                 return Ok(CompScheduling::Immediate);
             },
             CompMode::Sync => {
                 // This component just sends a single message, then waits until
                 // consensus has been reached
                 if !self.did_perform_send {
                     sched_ctx.log("Sending random message");
                     let mut random = self.generator.next_u32() - self.random_minimum;
                     let random_delta = self.random_maximum - self.random_minimum;
                     random %= random_delta;
                     random += self.random_minimum;
                     let value_group = ValueGroup::new_stack(vec![Value::UInt32(random)]);
                     let port_handle = comp_ctx.get_port_handle(self.output_port_id);
                     let port_info = comp_ctx.get_port(port_handle);
                     let scheduling = if port_info.state.is_blocked() {
                         // Need to wait until we can send the message
                         self.exec_state.set_as_blocked_put(self.output_port_id, value_group);
                         CompScheduling::Sleep
                     } else {
                         let message = self.consensus.annotate_data_message(comp_ctx, port_info, value_group);
                         let peer_handle = comp_ctx.get_peer_handle(port_info.peer_comp_id);
                         let peer_info = comp_ctx.get_peer(peer_handle);
                         peer_info.handle.send_message(sched_ctx, Message::Data(message), true);
+                        peer_info.handle.send_message(&sched_ctx.runtime, Message::Data(message), true);
                         // Remain in sync mode, but after `did_perform_send` was
                         // set to true.
                         CompScheduling::Immediate
                     };
                     // Blocked or not, we set `did_perform_send` to true. If
                     // blocked then the moment we become unblocked (and are back
                     // at the `Sync` mode) we have sent the message.
                     self.did_perform_send = true;
                     self.num_sends += 1;
                     return Ok(scheduling)
                 } else {
                     // Message was sent, finish this sync round
                     sched_ctx.log("Waiting for consensus");
                     self.exec_state.mode = CompMode::SyncEnd;
                     let decision = self.consensus.notify_sync_end(sched_ctx, comp_ctx);
                     self.handle_sync_decision(sched_ctx, comp_ctx, decision);
                     return Ok(CompScheduling::Requeue);
+                }
             },
             CompMode::SyncEnd | CompMode::BlockedPut => return Ok(CompScheduling::Sleep),
             CompMode::StartExit => return Ok(component::default_handle_start_exit(
                 &mut self.exec_state, &mut self.control, sched_ctx, comp_ctx
             )),
             CompMode::BusyExit => return Ok(component::default_handle_busy_exit(
                 &mut self.exec_state, &self.control, sched_ctx
             )),
             CompMode::Exit => return Ok(component::default_handle_exit(&self.exec_state)),
+        }
+    }
+}
 impl ComponentRandomU32 {
     pub(crate) fn new(arguments: ValueGroup) -> Self {
         debug_assert_eq!(arguments.values.len(), 4);
         debug_assert!(arguments.regions.is_empty());
         let port_id = component::port_id_from_eval(arguments.values[0].as_port_id());
         let minimum = arguments.values[1].as_uint32();
         let maximum = arguments.values[2].as_uint32();
         let num_sends = arguments.values[3].as_uint32();
         return Self{
             output_port_id: port_id,
             random_minimum: minimum,
             random_maximum: maximum,
             num_sends: 0,
             max_num_sends: num_sends,
             generator: random::thread_rng(),
             exec_state: CompExecState::new(),
             did_perform_send: false,
             control: ControlLayer::default(),
             consensus: Consensus::new(),
+        }
+    }
     fn handle_sync_decision(&mut self, _sched_ctx: &SchedulerCtx, _comp_ctx: &mut CompCtx, decision: SyncRoundDecision) {
         let success = match decision {
             SyncRoundDecision::None => return,
             SyncRoundDecision::Solution => true,
             SyncRoundDecision::Failure => false,
         };
         debug_assert_eq!(self.exec_state.mode, CompMode::SyncEnd);
         if success {
             self.exec_state.mode = CompMode::NonSync;
             self.consensus.notify_sync_decision(decision);
         } else {
             self.exec_state.mode = CompMode::StartExit;
+        }
+    }
+}
@@ \ No newline at end of file @@

src/runtime2/component/component_pdl.rs

➞

Show inline comments

 use crate::random::Random;
 use crate::protocol::*;
 use crate::protocol::ast::ProcedureDefinitionId;
 use crate::protocol::eval::{
     PortId as EvalPortId, Prompt,
     ValueGroup, Value,
     EvalContinuation, EvalResult, EvalError
 };
 use crate::runtime2::scheduler::SchedulerCtx;
 use crate::runtime2::communication::*;
 use super::component::{
     self,
     CompExecState, Component, CompScheduling, CompMode,
     port_id_from_eval, port_id_to_eval
 };
 use super::component_context::*;
 use super::control_layer::*;
 use super::consensus::Consensus;
 pub enum ExecStmt {
     CreatedChannel((Value, Value)),
     PerformedPut,
     PerformedGet(ValueGroup),
     PerformedSelectWait(u32),
     None,
+}
 impl ExecStmt {
     fn take(&mut self) -> ExecStmt {
         let mut value = ExecStmt::None;
         std::mem::swap(self, &mut value);
         return value;
+    }
     fn is_none(&self) -> bool {
         match self {
             ExecStmt::None => return true,
             _ => return false,
+        }
+    }
+}
 pub struct ExecCtx {
     stmt: ExecStmt,
+}
 impl RunContext for ExecCtx {
     fn performed_put(&mut self, _port: EvalPortId) -> bool {
         match self.stmt.take() {
             ExecStmt::None => return false,
             ExecStmt::PerformedPut => return true,
             _ => unreachable!(),
+        }
+    }
     fn performed_get(&mut self, _port: EvalPortId) -> Option<ValueGroup> {
         match self.stmt.take() {
             ExecStmt::None => return None,
             ExecStmt::PerformedGet(value) => return Some(value),
             _ => unreachable!(),
+        }
+    }
     fn fires(&mut self, _port: EvalPortId) -> Option<Value> {
         todo!("remove fires")
+    }
     fn performed_fork(&mut self) -> Option<bool> {
         todo!("remove fork")
+    }
     fn created_channel(&mut self) -> Option<(Value, Value)> {
         match self.stmt.take() {
             ExecStmt::None => return None,
             ExecStmt::CreatedChannel(ports) => return Some(ports),
             _ => unreachable!(),
+        }
+    }
     fn performed_select_wait(&mut self) -> Option<u32> {
         match self.stmt.take() {
             ExecStmt::None => return None,
             ExecStmt::PerformedSelectWait(selected_case) => Some(selected_case),
             _v => unreachable!(),
+        }
+    }
+}
 struct SelectCase {
     involved_ports: Vec<LocalPortHandle>,
+}
 // TODO: @Optimize, flatten cases into single array, have index-pointers to next case
 struct SelectState {
     cases: Vec<SelectCase>,
     next_case: u32,
     num_cases: u32,
     random: Random,
     candidates_workspace: Vec<usize>,
+}
 enum SelectDecision {
     None,
     Case(u32), // contains case index, should be passed along to PDL code
+}
 type InboxMain = Vec<Option<DataMessage>>;
 impl SelectState {
     fn new() -> Self {
         return Self{
             cases: Vec::new(),
             next_case: 0,
             num_cases: 0,
             random: Random::new(),
             candidates_workspace: Vec::new(),
+        }
+    }
     fn handle_select_start(&mut self, num_cases: u32) {
         self.cases.clear();
         self.next_case = 0;
         self.num_cases = num_cases;
+    }
     /// Register a port as belonging to a particular case. As for correctness of
     /// PDL code one cannot register the same port twice, this function might
     /// return an error
     fn register_select_case_port(&mut self, comp_ctx: &CompCtx, case_index: u32, _port_index: u32, port_id: PortId) -> Result<(), PortId> {
         // Retrieve case and port handle
         self.ensure_at_case(case_index);
         let cur_case = &mut self.cases[case_index as usize];
         let port_handle = comp_ctx.get_port_handle(port_id);
         debug_assert_eq!(cur_case.involved_ports.len(), _port_index as usize);
         // Make sure port wasn't added before, we disallow having the same port
         // in the same select guard twice.
         if cur_case.involved_ports.contains(&port_handle) {
             return Err(port_id);
+        }
         cur_case.involved_ports.push(port_handle);
         return Ok(());
+    }
     /// Notification that all ports have been registered and we should now wait
     /// until the appropriate messages have come in.
     fn handle_select_waiting_point(&mut self, inbox: &InboxMain, comp_ctx: &CompCtx) -> SelectDecision {
         if self.num_cases != self.next_case {
             // This happens when there are >=1 select cases written at the end
             // of the select block.
             self.ensure_at_case(self.num_cases - 1);
+        }
         return self.has_decision(inbox, comp_ctx);
+    }
     fn handle_updated_inbox(&mut self, inbox: &InboxMain, comp_ctx: &CompCtx) -> SelectDecision {
         return self.has_decision(inbox, comp_ctx);
+    }
     /// Internal helper, pushes empty cases inbetween last case and provided new
     /// case index.
     fn ensure_at_case(&mut self, new_case_index: u32) {
         // Push an empty case for all intermediate cases that were not
         // registered with a port.
         debug_assert!(new_case_index >= self.next_case && new_case_index < self.num_cases);
         for _ in self.next_case..new_case_index + 1 {
             self.cases.push(SelectCase{ involved_ports: Vec::new() });
+        }
         self.next_case = new_case_index + 1;
+    }
     /// Checks if a decision can be reached
     fn has_decision(&mut self, inbox: &InboxMain, comp_ctx: &CompCtx) -> SelectDecision {
         self.candidates_workspace.clear();
         if self.cases.is_empty() {
             // If there are no cases then we can immediately reach a "bogus
             // decision".
             return SelectDecision::Case(0);
+        }
         // Need to check for valid case
         'case_loop: for (case_index, case) in self.cases.iter().enumerate() {
             for port_handle in case.involved_ports.iter().copied() {
                 let port_index = comp_ctx.get_port_index(port_handle);
                 if inbox[port_index].is_none() {
                     // Condition not satisfied
                     continue 'case_loop;
+                }
+            }
             // If here then the case guard is satisfied
             self.candidates_workspace.push(case_index);
+        }
         if self.candidates_workspace.is_empty() {
             return SelectDecision::None;
         } else {
             let candidate_index = self.random.get_u64() as usize % self.candidates_workspace.len();
             return SelectDecision::Case(self.candidates_workspace[candidate_index] as u32);
+        }
+    }
+}
 pub(crate) struct CompPDL {
     pub exec_state: CompExecState,
     select_state: SelectState,
     pub prompt: Prompt,
     pub control: ControlLayer,
     pub consensus: Consensus,
     pub sync_counter: u32,
     pub exec_ctx: ExecCtx,
     // TODO: Temporary field, simulates future plans of having one storage place
     //  reserved per port.
     // Should be same length as the number of ports. Corresponding indices imply
     // message is intended for that port.
     pub inbox_main: InboxMain,
     pub inbox_backup: Vec<DataMessage>,
+}
 impl Component for CompPDL {
     fn adopt_message(&mut self, comp_ctx: &mut CompCtx, message: DataMessage) {
         let port_handle = comp_ctx.get_port_handle(message.data_header.target_port);
         let port_index = comp_ctx.get_port_index(port_handle);
         if self.inbox_main[port_index].is_none() {
             self.inbox_main[port_index] = Some(message);
         } else {
             self.inbox_backup.push(message);
+        }
+    }
     fn handle_message(&mut self, sched_ctx: &mut SchedulerCtx, comp_ctx: &mut CompCtx, mut message: Message) {
         sched_ctx.log(&format!("handling message: {:#?}", message));
         if let Some(new_target) = self.control.should_reroute(&mut message) {
             let mut target = sched_ctx.runtime.get_component_public(new_target);
             target.send_message(sched_ctx, message, false); // not waking up: we schedule once we've received all PortPeerChanged Acks
+            target.send_message(&sched_ctx.runtime, message, false); // not waking up: we schedule once we've received all PortPeerChanged Acks
             let _should_remove = target.decrement_users();
             debug_assert!(_should_remove.is_none());
             return;
+        }
         match message {
             Message::Data(message) => {
                 self.handle_incoming_data_message(sched_ctx, comp_ctx, message);
             },
             Message::Control(message) => {
                 component::default_handle_control_message(
                     &mut self.exec_state, &mut self.control, &mut self.consensus,
                     message, sched_ctx, comp_ctx
                 );
             },
             Message::Sync(message) => {
                 self.handle_incoming_sync_message(sched_ctx, comp_ctx, message);
             },
             Message::Poll => {
                 unreachable!(); // because we never register at the polling thread
+            }
+        }
+    }
     fn run(&mut self, sched_ctx: &mut SchedulerCtx, comp_ctx: &mut CompCtx) -> Result<CompScheduling, EvalError> {
         use EvalContinuation as EC;
         sched_ctx.log(&format!("Running component (mode: {:?})", self.exec_state.mode));
         // Depending on the mode don't do anything at all, take some special
         // actions, or fall through and run the PDL code.
         match self.exec_state.mode {
             CompMode::NonSync | CompMode::Sync => {
                 // continue and run PDL code
             },
             CompMode::SyncEnd | CompMode::BlockedGet | CompMode::BlockedPut | CompMode::BlockedSelect => {
                 return Ok(CompScheduling::Sleep);
+            }
             CompMode::StartExit => return Ok(component::default_handle_start_exit(
                 &mut self.exec_state, &mut self.control, sched_ctx, comp_ctx
             )),
             CompMode::BusyExit => return Ok(component::default_handle_busy_exit(
                 &mut self.exec_state, &self.control, sched_ctx
             )),
             CompMode::Exit => return Ok(component::default_handle_exit(&self.exec_state)),
+        }
         let run_result = self.execute_prompt(&sched_ctx)?;
         match run_result {
             EC::Stepping => unreachable!(), // execute_prompt runs until this is no longer returned
             EC::BranchInconsistent | EC::NewFork | EC::BlockFires(_) => todo!("remove these"),
             // Results that can be returned in sync mode
             EC::SyncBlockEnd => {
                 debug_assert_eq!(self.exec_state.mode, CompMode::Sync);
                 self.handle_sync_end(sched_ctx, comp_ctx);
                 return Ok(CompScheduling::Immediate);
             },
             EC::BlockGet(port_id) => {
                 debug_assert_eq!(self.exec_state.mode, CompMode::Sync);
                 debug_assert!(self.exec_ctx.stmt.is_none());
                 let port_id = port_id_from_eval(port_id);
                 let port_handle = comp_ctx.get_port_handle(port_id);
                 let port_index = comp_ctx.get_port_index(port_handle);
                 if let Some(message) = &self.inbox_main[port_index] {
                     // Check if we can actually receive the message
                     if self.consensus.try_receive_data_message(sched_ctx, comp_ctx, message) {
                         // Message was received. Make sure any blocked peers and
                         // pending messages are handled.
                         let message = self.inbox_main[port_index].take().unwrap();
                         self.handle_received_data_message(sched_ctx, comp_ctx, port_handle);
                         self.exec_ctx.stmt = ExecStmt::PerformedGet(message.content);
                         return Ok(CompScheduling::Immediate);
                     } else {
                         todo!("handle sync failure due to message deadlock");
                         return Ok(CompScheduling::Sleep);
+                    }
                 } else {
                     // We need to wait
                     self.exec_state.set_as_blocked_get(port_id);
                     return Ok(CompScheduling::Sleep);
+                }
             },
             EC::Put(port_id, value) => {
                 debug_assert_eq!(self.exec_state.mode, CompMode::Sync);
                 sched_ctx.log(&format!("Putting value {:?}", value));
                 let port_id = port_id_from_eval(port_id);
                 let port_handle = comp_ctx.get_port_handle(port_id);
                 let port_info = comp_ctx.get_port(port_handle);
                 if port_info.state.is_blocked() {
                     self.exec_state.set_as_blocked_put(port_id, value);
                     self.exec_ctx.stmt = ExecStmt::PerformedPut; // prepare for when we become unblocked
                     return Ok(CompScheduling::Sleep);
                 } else {
                     self.send_data_message_and_wake_up(sched_ctx, comp_ctx, port_handle, value);
                     self.exec_ctx.stmt = ExecStmt::PerformedPut;
                     return Ok(CompScheduling::Immediate);
+                }
             },
             EC::SelectStart(num_cases, _num_ports) => {
                 debug_assert_eq!(self.exec_state.mode, CompMode::Sync);
                 self.select_state.handle_select_start(num_cases);
                 return Ok(CompScheduling::Requeue);
             },
             EC::SelectRegisterPort(case_index, port_index, port_id) => {
                 debug_assert_eq!(self.exec_state.mode, CompMode::Sync);
                 let port_id = port_id_from_eval(port_id);
                 if let Err(_err) = self.select_state.register_select_case_port(comp_ctx, case_index, port_index, port_id) {
                     todo!("handle registering a port multiple times");
+                }
                 return Ok(CompScheduling::Immediate);
             },
             EC::SelectWait => {
                 debug_assert_eq!(self.exec_state.mode, CompMode::Sync);
                 let select_decision = self.select_state.handle_select_waiting_point(&self.inbox_main, comp_ctx);
                 if let SelectDecision::Case(case_index) = select_decision {
                     // Reached a conclusion, so we can continue immediately
                     self.exec_ctx.stmt = ExecStmt::PerformedSelectWait(case_index);
                     self.exec_state.mode = CompMode::Sync;
                     return Ok(CompScheduling::Immediate);
                 } else {
                     // No decision yet
                     self.exec_state.mode = CompMode::BlockedSelect;
                     return Ok(CompScheduling::Sleep);
+                }
             },
             // Results that can be returned outside of sync mode
             EC::ComponentTerminated => {
                 self.exec_state.mode = CompMode::StartExit; // next call we'll take care of the exit
                 return Ok(CompScheduling::Immediate);
             },
             EC::SyncBlockStart => {
                 debug_assert_eq!(self.exec_state.mode, CompMode::NonSync);
                 self.handle_sync_start(sched_ctx, comp_ctx);
                 return Ok(CompScheduling::Immediate);
             },
             EC::NewComponent(definition_id, type_id, arguments) => {
                 debug_assert_eq!(self.exec_state.mode, CompMode::NonSync);
                 self.create_component_and_transfer_ports(
                     sched_ctx, comp_ctx,
                     definition_id, type_id, arguments
                 );
                 return Ok(CompScheduling::Requeue);
             },
             EC::NewChannel => {
                 debug_assert_eq!(self.exec_state.mode, CompMode::NonSync);
                 debug_assert!(self.exec_ctx.stmt.is_none());
                 let channel = comp_ctx.create_channel();
                 self.exec_ctx.stmt = ExecStmt::CreatedChannel((
                     Value::Output(port_id_to_eval(channel.putter_id)),
                     Value::Input(port_id_to_eval(channel.getter_id))
                 ));
                 self.inbox_main.push(None);
                 self.inbox_main.push(None);
                 return Ok(CompScheduling::Immediate);
+            }
+        }
+    }
+}
 impl CompPDL {
     pub(crate) fn new(initial_state: Prompt, num_ports: usize) -> Self {
         let mut inbox_main = Vec::new();
         inbox_main.reserve(num_ports);
         for _ in 0..num_ports {
             inbox_main.push(None);
+        }
         return Self{
             exec_state: CompExecState::new(),
             select_state: SelectState::new(),
             prompt: initial_state,
             control: ControlLayer::default(),
             consensus: Consensus::new(),
             sync_counter: 0,
             exec_ctx: ExecCtx{
                 stmt: ExecStmt::None,
             },
             inbox_main,
             inbox_backup: Vec::new(),
+        }
+    }
     // -------------------------------------------------------------------------
     // Running component and handling changes in global component state
     // -------------------------------------------------------------------------
     fn execute_prompt(&mut self, sched_ctx: &SchedulerCtx) -> EvalResult {
         let mut step_result = EvalContinuation::Stepping;
         while let EvalContinuation::Stepping = step_result {
             step_result = self.prompt.step(
                 &sched_ctx.runtime.protocol.types, &sched_ctx.runtime.protocol.heap,
                 &sched_ctx.runtime.protocol.modules, &mut self.exec_ctx,
             )?;
+        }
         return Ok(step_result)
+    }
     fn handle_sync_start(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx) {
         sched_ctx.log("Component starting sync mode");
         self.consensus.notify_sync_start(comp_ctx);
         for message in self.inbox_main.iter() {
             if let Some(message) = message {
                 self.consensus.handle_new_data_message(comp_ctx, message);
+            }
+        }
         debug_assert_eq!(self.exec_state.mode, CompMode::NonSync);
         self.exec_state.mode = CompMode::Sync;
+    }
     /// Handles end of sync. The conclusion to the sync round might arise
     /// immediately (and be handled immediately), or might come later through
     /// messaging. In any case the component should be scheduled again
     /// immediately
     fn handle_sync_end(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx) {
         sched_ctx.log("Component ending sync mode (now waiting for solution)");
         let decision = self.consensus.notify_sync_end(sched_ctx, comp_ctx);
         self.exec_state.mode = CompMode::SyncEnd;
         self.handle_sync_decision(sched_ctx, comp_ctx, decision);
+    }
     /// Handles decision from the consensus round. This will cause a change in
     /// the internal `Mode`, such that the next call to `run` can take the
     /// appropriate next steps.
     fn handle_sync_decision(&mut self, sched_ctx: &SchedulerCtx, _comp_ctx: &mut CompCtx, decision: SyncRoundDecision) {
         sched_ctx.log(&format!("Handling sync decision: {:?} (in mode {:?})", decision, self.exec_state.mode));
         match decision {
             SyncRoundDecision::None => {
                 // No decision yet
                 return;
             },
             SyncRoundDecision::Solution => {
                 debug_assert_eq!(self.exec_state.mode, CompMode::SyncEnd);
                 self.exec_state.mode = CompMode::NonSync;
                 self.consensus.notify_sync_decision(decision);
             },
             SyncRoundDecision::Failure => {
                 debug_assert_eq!(self.exec_state.mode, CompMode::SyncEnd);
                 self.exec_state.mode = CompMode::StartExit;
             },
+        }
+    }
     fn handle_component_exit(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx) {
         sched_ctx.log("Component exiting");
         debug_assert_eq!(self.exec_state.mode, CompMode::StartExit);
         self.exec_state.mode = CompMode::BusyExit;
         // Doing this by index, then retrieving the handle is a bit rediculous,
         // but Rust is being Rust with its borrowing rules.
         for port_index in 0..comp_ctx.num_ports() {
             let port = comp_ctx.get_port_by_index_mut(port_index);
             if port.state == PortState::Closed {
                 // Already closed, or in the process of being closed
                 continue;
+            }
             // Mark as closed
             let port_id = port.self_id;
             port.state = PortState::Closed;
             // Notify peer of closing
             let port_handle = comp_ctx.get_port_handle(port_id);
             let (peer, message) = self.control.initiate_port_closing(port_handle, comp_ctx);
             let peer_info = comp_ctx.get_peer(peer);
             peer_info.handle.send_message(sched_ctx, Message::Control(message), true);
+            peer_info.handle.send_message(&sched_ctx.runtime, Message::Control(message), true);
+        }
+    }
     // -------------------------------------------------------------------------
     // Handling messages
     // -------------------------------------------------------------------------
     fn send_data_message_and_wake_up(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &CompCtx, source_port_handle: LocalPortHandle, value: ValueGroup) {
         let port_info = comp_ctx.get_port(source_port_handle);
         let peer_handle = comp_ctx.get_peer_handle(port_info.peer_comp_id);
         let peer_info = comp_ctx.get_peer(peer_handle);
         let annotated_message = self.consensus.annotate_data_message(comp_ctx, port_info, value);
         peer_info.handle.send_message(sched_ctx, Message::Data(annotated_message), true);
+        peer_info.handle.send_message(&sched_ctx.runtime, Message::Data(annotated_message), true);
+    }
     /// Handles a message that came in through the public inbox. This function
     /// will handle putting it in the correct place, and potentially blocking
     /// the port in case too many messages are being received.
     fn handle_incoming_data_message(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx, message: DataMessage) {
         // Whatever we do, glean information from headers in message
         if self.exec_state.mode.is_in_sync_block() {
             self.consensus.handle_new_data_message(comp_ctx, &message);
+        }
         // Check if we can insert it directly into the storage associated with
         // the port
         let target_port_id = message.data_header.target_port;
         let port_handle = comp_ctx.get_port_handle(target_port_id);
         let port_index = comp_ctx.get_port_index(port_handle);
         if self.inbox_main[port_index].is_none() {
             self.inbox_main[port_index] = Some(message);
             // After direct insertion, check if this component's execution is
             // blocked on receiving a message on that port
             debug_assert!(!comp_ctx.get_port(port_handle).state.is_blocked()); // because we could insert directly
             if self.exec_state.is_blocked_on_get(target_port_id) {
                 // We were indeed blocked
                 self.exec_state.mode = CompMode::Sync;
                 self.exec_state.mode_port = PortId::new_invalid();
             } else if self.exec_state.mode == CompMode::BlockedSelect {
                 let select_decision = self.select_state.handle_updated_inbox(&self.inbox_main, comp_ctx);
                 if let SelectDecision::Case(case_index) = select_decision {
                     self.exec_ctx.stmt = ExecStmt::PerformedSelectWait(case_index);
                     self.exec_state.mode = CompMode::Sync;
+                }
+            }
             return;
+        }
         // The direct inbox is full, so the port will become (or was already) blocked
         let port_info = comp_ctx.get_port_mut(port_handle);
         debug_assert!(port_info.state == PortState::Open || port_info.state.is_blocked());
         if port_info.state == PortState::Open {
             comp_ctx.set_port_state(port_handle, PortState::BlockedDueToFullBuffers);
             let (peer_handle, message) =
                 self.control.initiate_port_blocking(comp_ctx, port_handle);
             let peer = comp_ctx.get_peer(peer_handle);
             peer.handle.send_message(sched_ctx, Message::Control(message), true);
+            peer.handle.send_message(&sched_ctx.runtime, Message::Control(message), true);
+        }
         // But we still need to remember the message, so:
         self.inbox_backup.push(message);
+    }
     /// Handles when a message has been handed off from the inbox to the PDL
     /// code. We check to see if there are more messages waiting and, if not,
     /// then we handle the case where the port might have been blocked
     /// previously.
     fn handle_received_data_message(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx, port_handle: LocalPortHandle) {
         let port_index = comp_ctx.get_port_index(port_handle);
         debug_assert!(self.inbox_main[port_index].is_none()); // this function should be called after the message is taken out
         // Check for any more messages
         let port_info = comp_ctx.get_port(port_handle);
         for message_index in 0..self.inbox_backup.len() {
             let message = &self.inbox_backup[message_index];
             if message.data_header.target_port == port_info.self_id {
                 // One more message for this port
                 let message = self.inbox_backup.remove(message_index);
                 debug_assert!(comp_ctx.get_port(port_handle).state.is_blocked()); // since we had >1 message on the port
                 self.inbox_main[port_index] = Some(message);
                 return;
+            }
+        }
         // Did not have any more messages. So if we were blocked, then we need
         // to send the "unblock" message.
         if port_info.state == PortState::BlockedDueToFullBuffers {
             comp_ctx.set_port_state(port_handle, PortState::Open);
             let (peer_handle, message) = self.control.cancel_port_blocking(comp_ctx, port_handle);
             let peer_info = comp_ctx.get_peer(peer_handle);
             peer_info.handle.send_message(sched_ctx, Message::Control(message), true);
+            peer_info.handle.send_message(&sched_ctx.runtime, Message::Control(message), true);
+        }
+    }
     fn handle_incoming_sync_message(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx, message: SyncMessage) {
         let decision = self.consensus.receive_sync_message(sched_ctx, comp_ctx, message);
         self.handle_sync_decision(sched_ctx, comp_ctx, decision);
+    }
     // -------------------------------------------------------------------------
     // Handling ports
     // -------------------------------------------------------------------------
     fn create_component_and_transfer_ports(
         &mut self,
         sched_ctx: &SchedulerCtx, creator_ctx: &mut CompCtx,
         definition_id: ProcedureDefinitionId, type_id: TypeId, mut arguments: ValueGroup
     ) {
         struct PortPair{
             creator_handle: LocalPortHandle,
             creator_id: PortId,
             created_handle: LocalPortHandle,
             created_id: PortId,
+        }
         let mut opened_port_id_pairs = Vec::new();
         let mut closed_port_id_pairs = Vec::new();
         // TODO: @Nocommit
         let other_proc = &sched_ctx.runtime.protocol.heap[definition_id];
         let self_proc = &sched_ctx.runtime.protocol.heap[self.prompt.frames[0].definition];
         let reservation = sched_ctx.runtime.start_create_pdl_component();
         let mut created_ctx = CompCtx::new(&reservation);
         println!(
             "DEBUG: Comp '{}' (ID {:?}) is creating comp '{}' (ID {:?})",
             self_proc.identifier.value.as_str(), creator_ctx.id,
             other_proc.identifier.value.as_str(), reservation.id()
         );
         let other_proc = &sched_ctx.runtime.protocol.heap[definition_id];
         let self_proc = &sched_ctx.runtime.protocol.heap[self.prompt.frames[0].definition];
         dbg_code!({
             sched_ctx.log(&format!(
                 "DEBUG: Comp '{}' (ID {:?}) is creating comp '{}' (ID {:?})",
                 self_proc.identifier.value.as_str(), creator_ctx.id,
                 other_proc.identifier.value.as_str(), reservation.id()
             ));
         });
         // Take all the ports ID that are in the `args` (and currently belong to
         // the creator component) and translate them into new IDs that are
         // associated with the component we're about to create
         let mut arg_iter = ValueGroupPortIter::new(&mut arguments);
         while let Some(port_reference) = arg_iter.next() {
             // Create port entry for new component
             let creator_port_id = port_reference.id;
             let creator_port_handle = creator_ctx.get_port_handle(creator_port_id);
             let creator_port = creator_ctx.get_port(creator_port_handle);
             let created_port_handle = created_ctx.add_port(
                 creator_port.peer_comp_id, creator_port.peer_port_id,
                 creator_port.kind, creator_port.state
             );
             let created_port = created_ctx.get_port(created_port_handle);
             let created_port_id = created_port.self_id;
             let port_id_pair = PortPair {
                 creator_handle: creator_port_handle,
                 creator_id: creator_port_id,
                 created_handle: created_port_handle,
                 created_id: created_port_id,
             };
             if creator_port.state == PortState::Closed {
                 closed_port_id_pairs.push(port_id_pair)
             } else {
                 opened_port_id_pairs.push(port_id_pair);
+            }
             // Modify value in arguments (bit dirty, but double vec in ValueGroup causes lifetime issues)
             let arg_value = if let Some(heap_pos) = port_reference.heap_pos {
                 &mut arg_iter.group.regions[heap_pos][port_reference.index]
             } else {
                 &mut arg_iter.group.values[port_reference.index]
             };
             match arg_value {
                 Value::Input(id) => *id = port_id_to_eval(created_port_id),
                 Value::Output(id) => *id = port_id_to_eval(created_port_id),
                 _ => unreachable!(),
+            }
+        }
         // For each transferred port pair set their peer components to the
         // correct values. This will only change the values for the ports of
         // the new component.
         let mut created_component_has_remote_peers = false;
         for pair in opened_port_id_pairs.iter() {
             let creator_port_info = creator_ctx.get_port(pair.creator_handle);
             let created_port_info = created_ctx.get_port_mut(pair.created_handle);
             if created_port_info.peer_comp_id == creator_ctx.id {
                 // Port peer is owned by the creator as well
                 let created_peer_port_index = opened_port_id_pairs
                     .iter()
                     .position(|v| v.creator_id == creator_port_info.peer_port_id);
                 match created_peer_port_index {
                     Some(created_peer_port_index) => {
                         // Peer port moved to the new component as well. So
                         // adjust IDs appropriately.
                         let peer_pair = &opened_port_id_pairs[created_peer_port_index];
                         created_port_info.peer_port_id = peer_pair.created_id;
                         created_port_info.peer_comp_id = reservation.id();
                         todo!("either add 'self peer', or remove that idea from Ctx altogether")
                     },
                     None => {
                         // Peer port remains with creator component.
                         created_port_info.peer_comp_id = creator_ctx.id;
                         created_ctx.add_peer(pair.created_handle, sched_ctx, creator_ctx.id, None);
+                    }
+                }
             } else {
                 // Peer is a different component. We'll deal with sending the
                 // appropriate messages later
                 let peer_handle = creator_ctx.get_peer_handle(created_port_info.peer_comp_id);
                 let peer_info = creator_ctx.get_peer(peer_handle);
                 created_ctx.add_peer(pair.created_handle, sched_ctx, peer_info.id, Some(&peer_info.handle));
                 created_component_has_remote_peers = true;
+            }
+        }
         // We'll now actually turn our reservation for a new component into an
         // actual component. Note that we initialize it as "not sleeping" as
         // its initial scheduling might be performed based on `Ack`s in response
         // to message exchanges between remote peers.
         let total_num_ports = opened_port_id_pairs.len() + closed_port_id_pairs.len();
         let component = component::create_component(&sched_ctx.runtime.protocol, definition_id, type_id, arguments, total_num_ports);
         let (created_key, component) = sched_ctx.runtime.finish_create_pdl_component(
             reservation, component, created_ctx, false,
         );
         // Now modify the creator's ports: remove every transferred port and
         // potentially remove the peer component.
         for pair in opened_port_id_pairs.iter() {
             // Remove peer if appropriate
             let creator_port_info = creator_ctx.get_port(pair.creator_handle);
             let creator_port_index = creator_ctx.get_port_index(pair.creator_handle);
             let creator_peer_comp_id = creator_port_info.peer_comp_id;
             creator_ctx.remove_peer(sched_ctx, pair.creator_handle, creator_peer_comp_id, false);
             creator_ctx.remove_port(pair.creator_handle);
             // Transfer any messages
             if let Some(mut message) = self.inbox_main.remove(creator_port_index) {
                 message.data_header.target_port = pair.created_id;
                 component.component.adopt_message(&mut component.ctx, message)
+            }
             let mut message_index = 0;
             while message_index < self.inbox_backup.len() {
                 let message = &self.inbox_backup[message_index];
                 if message.data_header.target_port == pair.creator_id {
                     // transfer message
                     let mut message = self.inbox_backup.remove(message_index);
                     message.data_header.target_port = pair.created_id;
                     component.component.adopt_message(&mut component.ctx, message);
                 } else {
                     message_index += 1;
+                }
+            }
             // Handle potential channel between creator and created component
             let created_port_info = component.ctx.get_port(pair.created_handle);
             if created_port_info.peer_comp_id == creator_ctx.id {
                 let peer_port_handle = creator_ctx.get_port_handle(created_port_info.peer_port_id);
                 let peer_port_info = creator_ctx.get_port_mut(peer_port_handle);
                 peer_port_info.peer_comp_id = component.ctx.id;
                 peer_port_info.peer_port_id = created_port_info.self_id;
                 creator_ctx.add_peer(peer_port_handle, sched_ctx, component.ctx.id, None);
+            }
+        }
         // Do the same for the closed ports
         for pair in closed_port_id_pairs.iter() {
             let port_index = creator_ctx.get_port_index(pair.creator_handle);
             creator_ctx.remove_port(pair.creator_handle);
             let _removed_message = self.inbox_main.remove(port_index);
             // In debug mode: since we've closed the port we shouldn't have any
             // messages for that port.
             debug_assert!(_removed_message.is_none());
             debug_assert!(!self.inbox_backup.iter().any(|v| v.data_header.target_port == pair.creator_id));
+        }
         // By now all ports and messages have been transferred. If there are any
         // peers that need to be notified about this new component, then we
         // initiate the protocol that will notify everyone here.
         if created_component_has_remote_peers {
             let created_ctx = &component.ctx;
             let schedule_entry_id = self.control.add_schedule_entry(created_ctx.id);
             for pair in opened_port_id_pairs.iter() {
                 let port_info = created_ctx.get_port(pair.created_handle);
                 if port_info.peer_comp_id != creator_ctx.id && port_info.peer_comp_id != created_ctx.id {
                     let message = self.control.add_reroute_entry(
                         creator_ctx.id, port_info.peer_port_id, port_info.peer_comp_id,
                         pair.creator_id, pair.created_id, created_ctx.id,
                         schedule_entry_id
                     );
                     let peer_handle = created_ctx.get_peer_handle(port_info.peer_comp_id);
                     let peer_info = created_ctx.get_peer(peer_handle);
                     peer_info.handle.send_message(sched_ctx, message, true);
+                    peer_info.handle.send_message(&sched_ctx.runtime, message, true);
+                }
+            }
         } else {
             // Peer can be scheduled immediately
             sched_ctx.runtime.enqueue_work(created_key);
+        }
+    }
+}
 /// Recursively goes through the value group, attempting to find ports.
 /// Duplicates will only be added once.
 pub(crate) fn find_ports_in_value_group(value_group: &ValueGroup, ports: &mut Vec<PortId>) {
     // Helper to check a value for a port and recurse if needed.
     fn find_port_in_value(group: &ValueGroup, value: &Value, ports: &mut Vec<PortId>) {
         match value {
             Value::Input(port_id) | Value::Output(port_id) => {
                 // This is an actual port
                 let cur_port = PortId(port_id.id);
                 for prev_port in ports.iter() {
                     if *prev_port == cur_port {
                         // Already added
                         return;
+                    }
+                }
                 ports.push(cur_port);
             },
             Value::Array(heap_pos) |
             Value::Message(heap_pos) |
             Value::String(heap_pos) |
             Value::Struct(heap_pos) |
             Value::Union(_, heap_pos) => {
                 // Reference to some dynamic thing which might contain ports,
                 // so recurse
                 let heap_region = &group.regions[*heap_pos as usize];
                 for embedded_value in heap_region {
                     find_port_in_value(group, embedded_value, ports);
+                }
             },
             _ => {}, // values we don't care about
+        }
+    }
     // Clear the ports, then scan all the available values
     ports.clear();
     for value in &value_group.values {
         find_port_in_value(value_group, value, ports);
+    }
+}
 struct ValueGroupPortIter<'a> {
     group: &'a mut ValueGroup,
     heap_stack: Vec<(usize, usize)>,
     index: usize,
+}
 impl<'a> ValueGroupPortIter<'a> {
     fn new(group: &'a mut ValueGroup) -> Self {
         return Self{ group, heap_stack: Vec::new(), index: 0 }
+    }
+}
 struct ValueGroupPortRef {
     id: PortId,
     heap_pos: Option<usize>, // otherwise: on stack
     index: usize,
+}
 impl<'a> Iterator for ValueGroupPortIter<'a> {
     type Item = ValueGroupPortRef;
     fn next(&mut self) -> Option<Self::Item> {
         // Enter loop that keeps iterating until a port is found
         loop {
             if let Some(pos) = self.heap_stack.last() {
                 let (heap_pos, region_index) = *pos;
                 if region_index >= self.group.regions[heap_pos].len() {
                     self.heap_stack.pop();
                     continue;
+                }
                 let value = &self.group.regions[heap_pos][region_index];
                 self.heap_stack.last_mut().unwrap().1 += 1;
                 match value {
                     Value::Input(id) | Value::Output(id) => {
                         let id = PortId(id.id);
                         return Some(ValueGroupPortRef{
                             id,
                             heap_pos: Some(heap_pos),
                             index: region_index,
                         });
                     },
                     _ => {},
+                }
                 if let Some(heap_pos) = value.get_heap_pos() {
                     self.heap_stack.push((heap_pos as usize, 0));
+                }
             } else {
                 if self.index >= self.group.values.len() {
                     return None;
+                }
                 let value = &mut self.group.values[self.index];
                 self.index += 1;
                 match value {
                     Value::Input(id) | Value::Output(id) => {
                         let id = PortId(id.id);
                         return Some(ValueGroupPortRef{
                             id,
                             heap_pos: None,
                             index: self.index - 1
                         });
                     },
                     _ => {},
+                }
                 // Not a port, check if we need to enter a heap region
                 if let Some(heap_pos) = value.get_heap_pos() {
                     self.heap_stack.push((heap_pos as usize, 0));
                 } // else: just consider the next value
+            }
+        }
+    }
+}
@@ \ No newline at end of file @@

src/runtime2/component/consensus.rs

➞

Show inline comments

 use crate::protocol::eval::ValueGroup;
 use crate::runtime2::scheduler::*;
 use crate::runtime2::runtime::*;
 use crate::runtime2::communication::*;
 use super::component_context::*;
 pub struct PortAnnotation {
     self_comp_id: CompId,
     self_port_id: PortId,
     peer_comp_id: CompId, // only valid for getter ports
     peer_port_id: PortId, // only valid for getter ports
     peer_discovered: bool, // only valid for getter ports
     mapping: Option<u32>,
     kind: PortKind,
+}
 impl PortAnnotation {
     fn new(comp_id: CompId, port_id: PortId, kind: PortKind) -> Self {
         return Self{
             self_comp_id: comp_id,
             self_port_id: port_id,
             peer_comp_id: CompId::new_invalid(),
             peer_port_id: PortId::new_invalid(),
             peer_discovered: false,
             mapping: None,
             kind,
+        }
+    }
+}
 #[derive(Debug, Eq, PartialEq)]
 enum Mode {
     NonSync,
     SyncBusy,
     SyncAwaitingSolution,
     SelectBusy,
     SelectWait,
+}
 struct SolutionCombiner {
     solution: SyncPartialSolution,
     matched_channels: usize,
+}
 impl SolutionCombiner {
     fn new() -> Self {
         return Self {
             solution: SyncPartialSolution::default(),
             matched_channels: 0,
+        }
+    }
     #[inline]
     fn has_contributions(&self) -> bool {
         return !self.solution.channel_mapping.is_empty();
+    }
     /// Returns a decision for the current round. If there is no decision (yet)
     /// then `RoundDecision::None` is returned.
     fn get_decision(&self) -> SyncRoundDecision {
         if self.matched_channels == self.solution.channel_mapping.len() {
             debug_assert_ne!(self.solution.decision, SyncRoundDecision::None);
             return self.solution.decision;
+        }
         return SyncRoundDecision::None; // even in case of failure: wait for everyone.
+    }
     fn combine_with_partial_solution(&mut self, partial: SyncPartialSolution) {
         debug_assert_ne!(self.solution.decision, SyncRoundDecision::Solution);
         debug_assert_ne!(partial.decision, SyncRoundDecision::Solution);
         if partial.decision == SyncRoundDecision::Failure {
             self.solution.decision = SyncRoundDecision::Failure;
+        }
         for entry in partial.channel_mapping {
             let channel_index = if entry.getter.is_some() && entry.putter.is_some() {
                 let channel_index = self.solution.channel_mapping.len();
                 self.solution.channel_mapping.push(entry);
                 channel_index
             } else if let Some(putter) = entry.putter {
                 self.combine_with_putter_port(putter)
             } else if let Some(getter) = entry.getter {
                 self.combine_with_getter_port(getter)
             } else {
                 unreachable!(); // both putter and getter are None
             };
             let channel = &self.solution.channel_mapping[channel_index];
             if let Some(consistent) = Self::channel_is_consistent(channel) {
                 if !consistent {
                     self.solution.decision = SyncRoundDecision::Failure;
+                }
                 self.matched_channels += 1;
+            }
+        }
         self.update_solution();
+    }
     /// Combines the currently stored global solution (if any) with the newly
     /// provided local solution. Make sure to check the `has_decision` return
     /// value afterwards.
     fn combine_with_local_solution(&mut self, _comp_id: CompId, solution: SyncLocalSolution) {
         debug_assert_ne!(self.solution.decision, SyncRoundDecision::Solution);
         // Combine partial solution with the local solution entries
         for entry in solution {
             // Match the current entry up with its peer endpoint, or add a new
             // entry.
             let channel_index = match entry {
                 SyncLocalSolutionEntry::Putter(putter) => {
                     self.combine_with_putter_port(putter)
                 },
                 SyncLocalSolutionEntry::Getter(getter) => {
                     self.combine_with_getter_port(getter)
+                }
             };
             // Check if channel is now consistent
             let channel = &self.solution.channel_mapping[channel_index];
             if let Some(consistent) = Self::channel_is_consistent(channel) {
                 if !consistent {
                     self.solution.decision = SyncRoundDecision::Failure;
+                }
                 self.matched_channels += 1;
+            }
+        }
         self.update_solution();
+    }
     /// Takes whatever partial solution is present in the solution combiner and
     /// returns it. The solution combiner's solution will end up being empty.
     /// This is used when a new leader is found and we need to pass along our
     /// partial results.
     fn take_partial_solution(&mut self) -> SyncPartialSolution {
         let mut partial_solution = SyncPartialSolution::default();
         std::mem::swap(&mut partial_solution, &mut self.solution);
         self.clear();
         return partial_solution;
+    }
     fn clear(&mut self) {
         self.solution.channel_mapping.clear();
         self.solution.decision = SyncRoundDecision::None;
         self.matched_channels = 0;
+    }
     // --- Small utilities for combining solutions
     fn combine_with_putter_port(&mut self, putter: SyncSolutionPutterPort) -> usize {
         let channel_index = self.get_channel_index_for_putter(putter.self_comp_id, putter.self_port_id);
         if let Some(channel_index) = channel_index {
             let channel = &mut self.solution.channel_mapping[channel_index];
             debug_assert!(channel.putter.is_none());
             channel.putter = Some(putter);
             return channel_index;
         } else {
             let channel_index = self.solution.channel_mapping.len();
             self.solution.channel_mapping.push(SyncSolutionChannel{
                 putter: Some(putter),
                 getter: None,
             });
             return channel_index;
+        }
+    }
     fn combine_with_getter_port(&mut self, getter: SyncSolutionGetterPort) -> usize {
         let channel_index = self.get_channel_index_for_getter(getter.peer_comp_id, getter.peer_port_id);
         if let Some(channel_index) = channel_index {
             let channel = &mut self.solution.channel_mapping[channel_index];
             debug_assert!(channel.getter.is_none());
             channel.getter = Some(getter);
             return channel_index;
         } else {
             let channel_index = self.solution.channel_mapping.len();
             self.solution.channel_mapping.push(SyncSolutionChannel{
                 putter: None,
                 getter: Some(getter)
             });
             return channel_index;
+        }
+    }
     /// Retrieve index of the channel containing a getter port that has received
     /// from the specified putter port.
     fn get_channel_index_for_putter(&self, putter_comp_id: CompId, putter_port_id: PortId) -> Option<usize> {
         for (channel_index, channel) in self.solution.channel_mapping.iter().enumerate() {
             if let Some(getter) = &channel.getter {
                 if getter.peer_comp_id == putter_comp_id && getter.peer_port_id == putter_port_id {
                     return Some(channel_index);
+                }
+            }
+        }
         return None;
+    }
     /// Retrieve index of the channel for a getter port. To find this channel
     /// the **peer** component/port IDs of the getter port are used.
     fn get_channel_index_for_getter(&self, peer_comp_id: CompId, peer_port_id: PortId) -> Option<usize> {
         for (channel_index, channel) in self.solution.channel_mapping.iter().enumerate() {
             if let Some(putter) = &channel.putter {
                 if putter.self_comp_id == peer_comp_id && putter.self_port_id == peer_port_id {
                     return Some(channel_index);
+                }
+            }
+        }
         return None;
+    }
     fn channel_is_consistent(channel: &SyncSolutionChannel) -> Option<bool> {
         if channel.putter.is_none() || channel.getter.is_none() {
             return None;
+        }
         let putter = channel.putter.as_ref().unwrap();
         let getter = channel.getter.as_ref().unwrap();
         return Some(putter.mapping == getter.mapping);
+    }
     /// Determines the global solution if all components have contributed their
     /// local solutions.
     fn update_solution(&mut self) {
         if self.matched_channels == self.solution.channel_mapping.len() {
             if self.solution.decision != SyncRoundDecision::Failure {
                 self.solution.decision = SyncRoundDecision::Solution;
+            }
+        }
+    }
+}
 /// Tracking consensus state
 pub struct Consensus {
     // General state of consensus manager
     mapping_counter: u32,
     mode: Mode,
     // State associated with sync round
     round_index: u32,
     highest_id: CompId,
     ports: Vec<PortAnnotation>,
     // State associated with arriving at a solution and being a (temporary)
     // leader in the consensus round
     solution: SolutionCombiner,
+}
 impl Consensus {
     pub(crate) fn new() -> Self {
         return Self{
             round_index: 0,
             highest_id: CompId::new_invalid(),
             ports: Vec::new(),
             mapping_counter: 0,
             mode: Mode::NonSync,
             solution: SolutionCombiner::new(),
+        }
+    }
     // -------------------------------------------------------------------------
     // Managing sync state
     // -------------------------------------------------------------------------
     /// Notifies the consensus management that the PDL code has reached the
     /// start of a sync block.
     pub(crate) fn notify_sync_start(&mut self, comp_ctx: &CompCtx) {
         debug_assert_eq!(self.mode, Mode::NonSync);
         self.highest_id = comp_ctx.id;
         self.mapping_counter = 0;
         self.mode = Mode::SyncBusy;
         // Make the internally stored port annotation array consistent with the
         // ports that the component currently owns. They should match by index
         // (i.e. annotation at index `i` corresponds to port `i` in `comp_ctx`).
         let mut needs_setting_ports = false;
         if comp_ctx.num_ports() != self.ports.len() {
             needs_setting_ports = true;
         } else {
             for (idx, port) in comp_ctx.iter_ports().enumerate() {
                 let comp_port_id = port.self_id;
                 let cons_port_id = self.ports[idx].self_port_id;
                 if comp_port_id != cons_port_id {
                     needs_setting_ports = true;
                     break;
+                }
+            }
+        }
         if needs_setting_ports {
             // Reset all ports
             self.ports.clear();
             self.ports.reserve(comp_ctx.num_ports());
             for port in comp_ctx.iter_ports() {
                 self.ports.push(PortAnnotation::new(comp_ctx.id, port.self_id, port.kind));
+            }
         } else {
             // Make sure that we consider all peers as undiscovered again
             for annotation in self.ports.iter_mut() {
                 annotation.peer_discovered = false;
+            }
+        }
+    }
     /// Notifies the consensus management that the PDL code has reached the end
     /// of a sync block. A local solution will be submitted, after which we wait
     /// until the participants in the round (hopefully) reach a conclusion.
     pub(crate) fn notify_sync_end(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &CompCtx) -> SyncRoundDecision {
         debug_assert_eq!(self.mode, Mode::SyncBusy);
         self.mode = Mode::SyncAwaitingSolution;
         // Submit our port mapping as a solution
         let mut local_solution = Vec::with_capacity(self.ports.len());
         for port in &self.ports {
             if let Some(mapping) = port.mapping {
                 let port_handle = comp_ctx.get_port_handle(port.self_port_id);
                 let port_info = comp_ctx.get_port(port_handle);
                 let new_entry = match port_info.kind {
                     PortKind::Putter => SyncLocalSolutionEntry::Putter(SyncSolutionPutterPort{
                         self_comp_id: comp_ctx.id,
                         self_port_id: port_info.self_id,
                         mapping
                     }),
                     PortKind::Getter => SyncLocalSolutionEntry::Getter(SyncSolutionGetterPort{
                         self_comp_id: comp_ctx.id,
                         self_port_id: port_info.self_id,
                         peer_comp_id: port.peer_comp_id,
                         peer_port_id: port.peer_port_id,
                         mapping
                     })
                 };
                 local_solution.push(new_entry);
+            }
+        }
         let decision = self.handle_local_solution(sched_ctx, comp_ctx, comp_ctx.id, local_solution);
         return decision;
+    }
     /// Notifies that a decision has been reached. Note that the caller should
     /// still take the appropriate actions based on the decision it is supplying
     /// to the consensus layer.
     pub(crate) fn notify_sync_decision(&mut self, _decision: SyncRoundDecision) {
         // Reset everything for the next round
         debug_assert_eq!(self.mode, Mode::SyncAwaitingSolution);
         self.mode = Mode::NonSync;
         self.round_index = self.round_index.wrapping_add(1);
         for port in self.ports.iter_mut() {
             port.mapping = None;
+        }
         self.solution.clear();
+    }
     // -------------------------------------------------------------------------
     // Handling inbound and outbound messages
     // -------------------------------------------------------------------------
     /// Prepares a set of values to be sent of a channel.
     pub(crate) fn annotate_data_message(&mut self, comp_ctx: &CompCtx, port_info: &Port, content: ValueGroup) -> DataMessage {
         debug_assert_eq!(self.mode, Mode::SyncBusy); // can only send between sync start and sync end
         debug_assert!(self.ports.iter().any(|v| v.self_port_id == port_info.self_id));
         let data_header = self.create_data_header_and_update_mapping(port_info);
         let sync_header = self.create_sync_header(comp_ctx);
         return DataMessage{ data_header, sync_header, content };
+    }
     /// Handles the arrival of a new data message (needs to be called for every
     /// new data message, even though it might not end up being received). This
     /// is used to determine peers of `get`ter ports.
     pub(crate) fn handle_new_data_message(&mut self, comp_ctx: &CompCtx, message: &DataMessage) {
         let target_handle = comp_ctx.get_port_handle(message.data_header.target_port);
         let target_index = comp_ctx.get_port_index(target_handle);
         let annotation = &mut self.ports[target_index];
         debug_assert!(
             !annotation.peer_discovered || (
                 annotation.peer_comp_id == message.sync_header.sending_id &&
                 annotation.peer_port_id == message.data_header.source_port
+            )
         );
         annotation.peer_comp_id = message.sync_header.sending_id;
         annotation.peer_port_id = message.data_header.source_port;
         annotation.peer_discovered = true;
+    }
     /// Checks if the data message can be received (due to port annotations), if
     /// it can then `true` is returned and the caller is responsible for handing
     /// the message of to the PDL code. Otherwise the message cannot be
     /// received.
     pub(crate) fn try_receive_data_message(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx, message: &DataMessage) -> bool {
         debug_assert_eq!(self.mode, Mode::SyncBusy);
         debug_assert!(self.ports.iter().any(|v| v.self_port_id == message.data_header.target_port));
         // Make sure the expected mapping matches the currently stored mapping
         for (peer_port_kind, expected_annotation) in &message.data_header.expected_mapping {
             // Determine our annotation, in order to do so we need to find the
             // port matching the peer ports
             let mut self_annotation = None;
             let mut self_annotation_found = false;
             match peer_port_kind {
                 PortAnnotationKind::Putter(peer_port) => {
                     for self_port in &self.ports {
                         if self_port.kind == PortKind::Getter &&
                             self_port.peer_discovered &&
                             self_port.peer_comp_id == peer_port.self_comp_id &&
                             self_port.peer_port_id == peer_port.self_port_id
+                        {
                             self_annotation = self_port.mapping;
                             self_annotation_found = true;
                             break;
+                        }
+                    }
                 },
                 PortAnnotationKind::Getter(peer_port) => {
                     if peer_port.peer_comp_id == comp_ctx.id {
                         // Peer indicates that we talked to it
                         let self_port_handle = comp_ctx.get_port_handle(peer_port.peer_port_id);
                         let self_port_index = comp_ctx.get_port_index(self_port_handle);
                         self_annotation = self.ports[self_port_index].mapping;
                         self_annotation_found = true;
+                    }
+                }
+            }
             if !self_annotation_found {
                 continue
+            }
             if self_annotation != *expected_annotation {
                 return false;
+            }
+        }
         // Expected mapping matches current mapping, so we will receive the message
         self.set_annotation(message.sync_header.sending_id, &message.data_header);
         // Handle the sync header embedded within the data message
         self.handle_sync_header(sched_ctx, comp_ctx, &message.sync_header);
         return true;
+    }
     /// Receives the sync message and updates the consensus state appropriately.
     pub(crate) fn receive_sync_message(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx, message: SyncMessage) -> SyncRoundDecision {
         // Whatever happens: handle the sync header (possibly changing the
         // currently registered leader)
         self.handle_sync_header(sched_ctx, comp_ctx, &message.sync_header);
         match message.content {
             SyncMessageContent::NotificationOfLeader => {
                 return SyncRoundDecision::None;
             },
             SyncMessageContent::LocalSolution(solution_generator_id, local_solution) => {
                 return self.handle_local_solution(sched_ctx, comp_ctx, solution_generator_id, local_solution);
             },
             SyncMessageContent::PartialSolution(partial_solution) => {
                 return self.handle_partial_solution(sched_ctx, comp_ctx, partial_solution);
             },
             SyncMessageContent::GlobalSolution => {
                 debug_assert_eq!(self.mode, Mode::SyncAwaitingSolution); // leader can only find global- if we submitted local solution
                 return SyncRoundDecision::Solution;
             },
             SyncMessageContent::GlobalFailure => {
                 debug_assert_eq!(self.mode, Mode::SyncAwaitingSolution);
                 return SyncRoundDecision::Failure;
+            }
+        }
+    }
     fn handle_sync_header(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx, header: &MessageSyncHeader) {
         if header.highest_id.0 > self.highest_id.0 {
             // Sender knows of someone with a higher ID. So store highest ID,
             // notify all peers, and forward local solutions
             self.highest_id = header.highest_id;
             for peer in comp_ctx.iter_peers() {
                 if peer.id == header.sending_id {
                     continue; // do not send to sender: it has the higher ID
+                }
                 // also: only send if we received a message in this round
                 let mut performed_communication = false; // TODO: Revise, temporary fix
                 for port in self.ports.iter() {
                     if port.peer_comp_id == peer.id && port.mapping.is_some() {
                         performed_communication = true;
                         break;
+                    }
+                }
                 if !performed_communication {
                     continue;
+                }
                 let message = SyncMessage{
                     sync_header: self.create_sync_header(comp_ctx),
                     content: SyncMessageContent::NotificationOfLeader,
                 };
                 peer.handle.send_message(sched_ctx, Message::Sync(message), true);
+                peer.handle.send_message(&sched_ctx.runtime, Message::Sync(message), true);
+            }
             self.forward_partial_solution(sched_ctx, comp_ctx);
         } else if header.highest_id.0 < self.highest_id.0 {
             // Sender has a lower ID, so notify it of our higher one
             let message = SyncMessage{
                 sync_header: self.create_sync_header(comp_ctx),
                 content: SyncMessageContent::NotificationOfLeader,
             };
             let peer_handle = comp_ctx.get_peer_handle(header.sending_id);
             let peer_info = comp_ctx.get_peer(peer_handle);
             peer_info.handle.send_message(sched_ctx, Message::Sync(message), true);
+            peer_info.handle.send_message(&sched_ctx.runtime, Message::Sync(message), true);
         } // else: exactly equal
+    }
     fn set_annotation(&mut self, source_comp_id: CompId, data_header: &MessageDataHeader) {
         for annotation in self.ports.iter_mut() {
             if annotation.self_port_id == data_header.target_port {
                 // Message should have already passed the `handle_new_data_message` function, so we
                 // should have already annotated the peer of the port.
                 debug_assert!(
                     annotation.peer_discovered &&
                     annotation.peer_comp_id == source_comp_id &&
                     annotation.peer_port_id == data_header.source_port
                 );
                 annotation.mapping = Some(data_header.new_mapping);
+            }
+        }
+    }
     // -------------------------------------------------------------------------
     // Leader-related methods
     // -------------------------------------------------------------------------
     fn forward_partial_solution(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx) {
         debug_assert_ne!(self.highest_id, comp_ctx.id); // not leader
         // Make sure that we have something to send
         if !self.solution.has_contributions() {
             return;
+        }
         // Swap the container with the partial solution and then send it along
         let partial_solution = self.solution.take_partial_solution();
         self.send_to_leader(sched_ctx, comp_ctx, Message::Sync(SyncMessage{
             sync_header: self.create_sync_header(comp_ctx),
             content: SyncMessageContent::PartialSolution(partial_solution),
         }));
+    }
     fn handle_local_solution(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &CompCtx, solution_sender_id: CompId, solution: SyncLocalSolution) -> SyncRoundDecision {
         if self.highest_id == comp_ctx.id {
             // We are the leader
             self.solution.combine_with_local_solution(solution_sender_id, solution);
             let round_decision = self.solution.get_decision();
             if round_decision != SyncRoundDecision::None {
                 self.broadcast_decision(sched_ctx, comp_ctx, round_decision);
+            }
             return round_decision;
         } else {
             // Forward the solution
             let message = SyncMessage{
                 sync_header: self.create_sync_header(comp_ctx),
                 content: SyncMessageContent::LocalSolution(solution_sender_id, solution),
             };
             self.send_to_leader(sched_ctx, comp_ctx, Message::Sync(message));
             return SyncRoundDecision::None;
+        }
+    }
     fn handle_partial_solution(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx, solution: SyncPartialSolution) -> SyncRoundDecision {
         if self.highest_id == comp_ctx.id {
             // We are the leader, combine existing and new solution
             self.solution.combine_with_partial_solution(solution);
             let round_decision = self.solution.get_decision();
             if round_decision != SyncRoundDecision::None {
                 self.broadcast_decision(sched_ctx, comp_ctx, round_decision);
+            }
             return round_decision;
         } else {
             // Forward the partial solution
             let message = SyncMessage{
                 sync_header: self.create_sync_header(comp_ctx),
                 content: SyncMessageContent::PartialSolution(solution),
             };
             self.send_to_leader(sched_ctx, comp_ctx, Message::Sync(message));
             return SyncRoundDecision::None;
+        }
+    }
     fn broadcast_decision(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &CompCtx, decision: SyncRoundDecision) {
         debug_assert_eq!(self.highest_id, comp_ctx.id);
         let is_success = match decision {
             SyncRoundDecision::None => unreachable!(),
             SyncRoundDecision::Solution => true,
             SyncRoundDecision::Failure => false,
         };
         let mut peers = Vec::with_capacity(self.solution.solution.channel_mapping.len()); // TODO: @Performance
         for channel in self.solution.solution.channel_mapping.iter() {
             let getter = channel.getter.as_ref().unwrap();
             if getter.self_comp_id != comp_ctx.id && !peers.contains(&getter.self_comp_id) {
                 peers.push(getter.self_comp_id);
+            }
             if getter.peer_comp_id != comp_ctx.id && !peers.contains(&getter.peer_comp_id) {
                 peers.push(getter.peer_comp_id);
+            }
+        }
         for peer in peers {
             let mut handle = sched_ctx.runtime.get_component_public(peer);
             let message = Message::Sync(SyncMessage{
                 sync_header: self.create_sync_header(comp_ctx),
                 content: if is_success { SyncMessageContent::GlobalSolution } else { SyncMessageContent::GlobalFailure },
             });
             handle.send_message(sched_ctx, message, true);
+            handle.send_message(&sched_ctx.runtime, message, true);
             let _should_remove = handle.decrement_users();
             debug_assert!(_should_remove.is_none());
+        }
+    }
     fn send_to_leader(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &CompCtx, message: Message) {
         debug_assert_ne!(self.highest_id, comp_ctx.id); // we're not the leader
         let mut leader_info = sched_ctx.runtime.get_component_public(self.highest_id);
         leader_info.send_message(sched_ctx, message, true);
+        leader_info.send_message(&sched_ctx.runtime, message, true);
         let should_remove = leader_info.decrement_users();
         if let Some(key) = should_remove {
             sched_ctx.runtime.destroy_component(key);
+        }
+    }
     // -------------------------------------------------------------------------
     // Creating message headers
     // -------------------------------------------------------------------------
     fn create_data_header_and_update_mapping(&mut self, port_info: &Port) -> MessageDataHeader {
         let mut expected_mapping = Vec::with_capacity(self.ports.len());
         let mut port_index = usize::MAX;
         for (index, port) in self.ports.iter().enumerate() {
             if port.self_port_id == port_info.self_id {
                 port_index = index; // remember for later updating
+            }
             // Add all of the
             let annotation_kind = match port.kind {
                 PortKind::Putter => {
                     PortAnnotationKind::Putter(PortAnnotationPutter{
                         self_comp_id: port.self_comp_id,
                         self_port_id: port.self_port_id
                     })
                 },
                 PortKind::Getter => {
                     if !port.peer_discovered {
                         continue;
+                    }
                     PortAnnotationKind::Getter(PortAnnotationGetter{
                         self_comp_id: port.self_comp_id,
                         self_port_id: port.self_port_id,
                         peer_comp_id: port.peer_comp_id,
                         peer_port_id: port.peer_port_id,
                     })
+                }
             };
             expected_mapping.push((annotation_kind, port.mapping));
+        }
         let new_mapping = self.take_mapping();
         self.ports[port_index].mapping = Some(new_mapping);
         debug_assert_eq!(port_info.kind, PortKind::Putter);
         return MessageDataHeader{
             expected_mapping,
             new_mapping,
             source_port: port_info.self_id,
             target_port: port_info.peer_port_id,
         };
+    }
     #[inline]
     fn create_sync_header(&self, comp_ctx: &CompCtx) -> MessageSyncHeader {
         return MessageSyncHeader{
             sync_round: self.round_index,
             sending_id: comp_ctx.id,
             highest_id: self.highest_id,
         };
+    }
     #[inline]
     fn take_mapping(&mut self) -> u32 {
         let mapping = self.mapping_counter;
         self.mapping_counter = self.mapping_counter.wrapping_add(1);
         return mapping;
+    }
+}
@@ \ No newline at end of file @@

src/runtime2/component/mod.rs

➞

Show inline comments

 mod component_pdl;
 mod component_context;
 mod control_layer;
 mod consensus;
 mod component;
 mod component_ip;
 pub(crate) use component::{Component, CompScheduling};
 pub(crate) use component_pdl::{CompPDL};
 pub(crate) use component_context::CompCtx;
 pub(crate) use control_layer::{ControlId};
 use super::scheduler::*;
 use super::runtime::*;
 /// If the component is sleeping, then that flag will be atomically set to
 /// false. If we're the ones that made that happen then we add it to the work
 /// queue.
-pub(crate) fn wake_up_if_sleeping(sched_ctx: &SchedulerCtx, comp_id: CompId, handle: &CompHandle) {
+pub(crate) fn wake_up_if_sleeping(runtime: &RuntimeInner, comp_id: CompId, handle: &CompHandle) {
     use std::sync::atomic::Ordering;
     let should_wake_up = handle.sleeping
         .compare_exchange(true, false, Ordering::AcqRel, Ordering::Acquire)
         .is_ok();
     if should_wake_up {
         let comp_key = unsafe{ comp_id.upgrade() };
-        sched_ctx.runtime.enqueue_work(comp_key);
         runtime.enqueue_work(comp_key);
+    }
+}
@@ \ No newline at end of file @@

src/runtime2/error.rs

➞

Show inline comments

@@ new file 100644 @@
 use std::fmt::{Write, Debug, Display, Formatter as FmtFormatter, Result as FmtResult};
 /// Represents an unrecoverable runtime error that is reported to the user (for
 /// debugging purposes). Basically a human-readable message with its source
 /// location. The error is chainable.
 pub struct RtError {
     file: &'static str,
     line: u32,
     message: String,
     cause: Option<Box<RtError>>,
+}
 impl RtError {
     pub(crate) fn new(file: &'static str, line: u32, message: String) -> RtError {
         return RtError {
             file, line, message, cause: None,
+        }
+    }
     pub(crate) fn wrap(self, file: &'static str, line: u32, message: String) -> RtError {
         return RtError {
             file, line, message, cause: Some(Box::new(self))
+        }
+    }
+}
 impl Display for RtError {
     fn fmt(&self, f: &mut FmtFormatter<'_>) -> FmtResult {
         let mut error = self;
         loop {
             write!(f, "[{}:{}] {}", self.file, self.line, self.message).unwrap();
             match &error.cause {
                 Some(cause) => {
                     writeln!(f, " ...");
                     error = cause.as_ref()
                 },
                 None => {
                     writeln!(f).unwrap();
                 },
+            }
+        }
+    }
+}
 impl Debug for RtError {
     fn fmt(&self, f: &mut FmtFormatter<'_>) -> FmtResult {
         return (self as &dyn Display).fmt(f);
+    }
+}
 macro_rules! rt_error {
     ($fmt:expr) => {
         $crate::runtime2::error::RtError::new(file!(), line!(), $fmt.to_string())
     };
     ($fmt:expr, $($args:expr),*) => {
         $crate::runtime2::error::RtError::new(file!(), line!(), format!($fmt, $($args),*))
     };
+}
 macro_rules! rt_error_try {
     ($prev:expr, $($fmt_and_args:expr),*) => {
+        {
             let result = $prev;
             match result {
                 Ok(result) => result,
                 Err(result) => return Err(result.wrap(file!(), line!(), format!($($fmt_and_args),*))),
+            }
+        }
+    }
+}
@@ \ No newline at end of file @@

src/runtime2/mod.rs

➞

Show inline comments

 #[macro_use] mod error;
 mod store;
 mod runtime;
 mod component;
 mod communication;
 mod scheduler;
 mod poll;
 mod stdlib;
 #[cfg(test)] mod tests;
 pub use runtime::Runtime;
 pub(crate) use error::RtError;
 pub(crate) use scheduler::SchedulerCtx;
 pub(crate) use communication::{
     PortId, PortKind, PortState,
     Message, ControlMessage, SyncMessage, DataMessage,
     SyncRoundDecision
 };
@@ \ No newline at end of file @@

src/runtime2/poll/mod.rs

➞

Show inline comments

 use libc::{self, c_int};
 use std::{io, ptr, time};
 use std::{io, ptr, time, thread};
 use std::sync::Arc;
 use std::sync::atomic::{AtomicU32, Ordering};
 use std::collections::HashMap;
 use crate::runtime2::RtError;
 use crate::runtime2::runtime::{CompHandle, RuntimeInner};
 use crate::runtime2::store::queue_mpsc::*;
 pub(crate) type FileDescriptor = c_int;
 pub(crate) trait AsFileDescriptor {
     fn as_file_descriptor(&self) -> FileDescriptor;
+}
 pub(crate) struct UserData(u64);
 #[inline]
 pub(crate) fn register_polling<F: AsFileDescriptor>(
     poller: &Poller, entity: F, user: UserData, read: bool, write: bool
 ) -> io::Result<()> {
     let file_descriptor = entity.as_file_descriptor();
     return poller.register(file_descriptor, user, read, write);
+}
 #[derive(Copy, Clone)]
 pub(crate) struct UserData(u64);
 #[inline]
 pub(crate) fn unregister_polling<F: AsFileDescriptor>(
     poller: &Poller, entity: F
 ) -> io::Result<()> {
     let file_descriptor = entity.as_file_descriptor();
     return poller.unregister(file_descriptor);
+}
 // -----------------------------------------------------------------------------
 // Poller
 // -----------------------------------------------------------------------------
 #[cfg(unix)]
 pub(crate) struct Poller {
     handle: c_int,
     events: Vec<libc::epoll_event>
+}
 // All of this is gleaned from the `mio` crate.
 #[cfg(unix)]
 impl Poller {
     pub fn new(event_capacity: usize) -> io::Result<Self> {
         assert!(event_capacity < i32::MAX as usize); // because of argument to `epoll_wait`.
     pub fn new() -> io::Result<Self> {
         let handle = syscall_result(unsafe{ libc::epoll_create1(libc::EPOLL_CLOEXEC) })?;
         return Ok(Self{
             handle,
             events: Vec::with_capacity(event_capacity),
         })
+    }
     fn register(&self, fd: FileDescriptor, user: UserData, read: bool, write: bool) -> io::Result<()> {
         let mut event = libc::epoll_event{
             events: Self::events_from_rw_flags(read, write),
             u64: user.0,
         };
         syscall_result(unsafe{
             libc::epoll_ctl(self.handle, libc::EPOLL_CTL_ADD, fd, &mut event)
         })?;
         return Ok(());
+    }
     fn unregister(&self, fd: FileDescriptor) -> io::Result<()> {
         syscall_result(unsafe{
             libc::epoll_ctl(self.handle, libc::EPOLL_CTL_DEL, fd, ptr::null_mut())
         })?;
         return Ok(());
+    }
     pub fn wait(&mut self, timeout: time::Duration) -> io::Result<()> {
     /// Performs `epoll_wait`, waiting for the provided timeout or until events
     /// are reported. They are stored in the `events` variable (up to
     /// `events.cap()` are reported, so ensure it is preallocated).
     pub fn wait(&self, events: &mut Vec<libc::epoll_event>, timeout: time::Duration) -> io::Result<()> {
         // See `mio` for the reason. Works around a linux bug
         #[cfg(target_pointer_width = "32")]
         const MAX_TIMEOUT: u128 = 1789569;
         #[cfg(not(target_pointer_width = "32"))]
         const MAX_TIMEOUT: u128 = c_int::MAX as u128;
         let mut timeout_millis = timeout.as_millis();
         if timeout_millis > MAX_TIMEOUT {
             timeout_millis = -1; // effectively infinite
+        }
         let timeout_millis = timeout.as_millis();
         let timeout_millis = if timeout_millis > MAX_TIMEOUT {
             -1 // effectively infinite
         } else {
             timeout_millis as c_int
         };
         debug_assert!(events.is_empty());
         debug_assert!(events.capacity() > 0 && events.capacity() < i32::MAX as usize);
         let num_events = syscall_result(unsafe{
-            libc::epoll_wait(self.handle, self.events.as_mut(), self.events.capacity() as i32, timeout_millis)
+            libc::epoll_wait(self.handle, events.as_mut_ptr(), events.capacity() as i32, timeout_millis)
         })?;
         unsafe{
             debug_assert!(num_events >= 0);
-            self.events.set_len(num_events as usize);
             events.set_len(num_events as usize);
+        }
         return Ok(());
+    }
     fn events_from_rw_flags(read: bool, write: bool) -> u32 {
         let mut events = libc::EPOLLET;
         if read {
             events |= libc::EPOLLIN | libc::EPOLLRDHUP;
+        }
         if write {
             events |= libc::EPOLLOUT;
+        }
         return events as u32;
+    }
+}
 #[cfg(unix)]
 impl Drop for Poller {
     fn drop(&mut self) {
         unsafe{ libc::close(self.handle); }
+    }
+}
 #[inline]
 fn syscall_result(result: c_int) -> io::Result<c_int> {
     if result < 0 {
         return Err(io::Error::last_os_error());
     } else {
         return Ok(result);
+    }
+}
 #[cfg(not(unix))]
 struct Poller {
+}
 // -----------------------------------------------------------------------------
 // Polling Thread
 // -----------------------------------------------------------------------------
 enum PollCmd {
     Register(CompHandle, UserData),
     Unregister(FileDescriptor, UserData),
     Shutdown,
+}
 /// Represents the data needed to build interfaces to the polling thread (which
 /// should happen first) and to create the polling thread itself.
 pub(crate) struct PollingThreadBuilder {
     poller: Arc<Poller>,
     generation_counter: Arc<AtomicU32>,
     queue: QueueDynMpsc<PollCmd>,
     runtime: Arc<RuntimeInner>,
     logging_enabled: bool,
+}
 impl PollingThreadBuilder {
     pub(crate) fn new(runtime: Arc<RuntimeInner>, logging_enabled: bool) -> Result<PollingThreadBuilder, RtError> {
         let poller = Poller::new()
             .map_err(|e| rt_error!("failed to create poller, because: {}", e))?;
         return Ok(PollingThreadBuilder {
             poller: Arc::new(poller),
             generation_counter: Arc::new(AtomicU32::new(0)),
             queue: QueueDynMpsc::new(64),
             runtime,
             logging_enabled,
         })
+    }
     pub(crate) fn client(&self) -> PollingClient {
         return PollingClient{
             poller: self.poller.clone(),
             generation_counter: self.generation_counter.clone(),
             queue: self.queue.producer(),
+        }
+    }
     pub(crate) fn into_thread(self) -> (PollingThread, PollingThreadDestroyer) {
         let destroyer = self.queue.producer();
         return (
             PollingThread{
                 poller: self.poller,
                 runtime: self.runtime,
                 queue: self.queue,
                 logging_enabled: self.logging_enabled,
             },
             PollingThreadDestroyer::new(destroyer)
         );
+    }
+}
 pub(crate) struct PollingThread {
     poller: Arc<Poller>,
     runtime: Arc<RuntimeInner>,
     queue: QueueDynMpsc<PollCmd>,
     logging_enabled: bool,
+}
 impl PollingThread {
     pub(crate) fn run(&mut self) {
         use crate::runtime2::scheduler::SchedulerCtx;
         use crate::runtime2::communication::Message;
         const NUM_EVENTS: usize = 256;
         const EPOLL_DURATION: time::Duration = time::Duration::from_millis(250);
         // @performance: Lot of improvements possible here, a HashMap is likely
         // a horrible way to do this.
         let mut events = Vec::with_capacity(NUM_EVENTS);
         let mut lookup = HashMap::with_capacity(64);
         self.log("Starting polling thread");
         loop {
             // Retrieve events first (because the PollingClient will first
             // register at epoll, and then push a command into the queue).
             self.poller.wait(&mut events, EPOLL_DURATION).unwrap();
             // Then handle everything in the command queue.
             while let Some(command) = self.queue.pop() {
                 match command {
                     PollCmd::Register(handle, user_data) => {
                         self.log(&format!("Registering component {:?} as {}", handle.id(), user_data.0));
                         let key = Self::user_data_as_key(user_data);
                         debug_assert!(!lookup.contains_key(&key));
                         lookup.insert(key, handle);
                     },
                     PollCmd::Unregister(_file_descriptor, user_data) => {
                         let key = Self::user_data_as_key(user_data);
                         debug_assert!(lookup.contains_key(&key));
                         let mut handle = lookup.remove(&key).unwrap();
                         self.log(&format!("Unregistering component {:?} as {}", handle.id(), user_data.0));
                         if let Some(key) = handle.decrement_users() {
                             self.runtime.destroy_component(key);
+                        }
                     },
                     PollCmd::Shutdown => {
                         // The contract is that all scheduler threads shutdown
                         // before the polling thread. This happens when all
                         // components are removed.
                         self.log("Received shutdown signal");
                         debug_assert!(lookup.is_empty());
                         return;
+                    }
+                }
+            }
             // Now process all of the events. Because we might have had a
             // `Register` command followed by an `Unregister` command (e.g. a
             // component has died), we might get events that are not associated
             // with an entry in the lookup.
             for event in events.drain(..) {
                 let key = event.u64;
                 if let Some(handle) = lookup.get(&key) {
                     self.log(&format!("Sending poll to {:?} (event: {:x})", handle.id(), event.events));
                     handle.send_message(&self.runtime, Message::Poll, true);
+                }
+            }
+        }
+    }
     #[inline]
     fn user_data_as_key(data: UserData) -> u64 {
         return data.0;
+    }
     fn log(&self, message: &str) {
         if self.logging_enabled {
             println!("[polling] {}", message);
+        }
+    }
+}
 // bit convoluted, but it works
 pub(crate) struct PollingThreadDestroyer {
     queue: Option<QueueDynProducer<PollCmd>>,
+}
 impl PollingThreadDestroyer {
     fn new(queue: QueueDynProducer<PollCmd>) -> Self {
         return Self{ queue: Some(queue) };
+    }
     pub(crate) fn initiate_destruction(&mut self) {
         self.queue.take().unwrap().push(PollCmd::Shutdown);
+    }
+}
 impl Drop for PollingThreadDestroyer {
     fn drop(&mut self) {
         debug_assert!(self.queue.is_none());
+    }
+}
 pub(crate) struct PollTicket(FileDescriptor, u64);
 /// A structure that allows the owner to register components at the polling
 /// thread. Because of assumptions in the communication queue all of these
 /// clients should be dropped before stopping the polling thread.
 pub(crate) struct PollingClient {
     poller: Arc<Poller>,
     generation_counter: Arc<AtomicU32>,
     queue: QueueDynProducer<PollCmd>,
+}
 impl PollingClient {
     fn register<F: AsFileDescriptor>(&self, entity: F, handle: CompHandle, read: bool, write: bool) -> Result<PollTicket, RtError> {
         let generation = self.generation_counter.fetch_add(1, Ordering::Relaxed);
         let user_data = user_data_for_component(handle.id().0, generation);
         self.queue.push(PollCmd::Register(handle, user_data));
         let file_descriptor = entity.as_file_descriptor();
         self.poller.register(file_descriptor, user_data, read, write)
             .map_err(|e| rt_error!("failed to register for polling, because: {}", e))?;
         return Ok(PollTicket(file_descriptor, user_data.0));
+    }
     fn unregister(&self, ticket: PollTicket) -> Result<(), RtError> {
         let file_descriptor = ticket.0;
         let user_data = UserData(ticket.1);
         self.queue.push(PollCmd::Unregister(file_descriptor, user_data));
         self.poller.unregister(file_descriptor)
             .map_err(|e| rt_error!("failed to unregister polling, because: {}", e))?;
         return Ok(());
+    }
+}
 #[inline]
 fn user_data_for_component(component_id: u32, generation: u32) -> UserData {
     return UserData((generation as u64) << 32 | (component_id as u64));
+}
@@ \ No newline at end of file @@

src/runtime2/runtime.rs

➞

Show inline comments

 use std::sync::{Arc, Mutex, Condvar};
 use std::sync::atomic::{AtomicU32, AtomicBool, Ordering};
 use std::thread;
 use std::collections::VecDeque;
 use crate::protocol::*;
 use crate::runtime2::poll::{PollingThreadBuilder, PollingThreadDestroyer};
 use crate::runtime2::RtError;
 use super::communication::Message;
 use super::component::{Component, wake_up_if_sleeping, CompPDL, CompCtx};
 use super::store::{ComponentStore, ComponentReservation, QueueDynMpsc, QueueDynProducer};
 use super::scheduler::*;
 // -----------------------------------------------------------------------------
 // Component
 // -----------------------------------------------------------------------------
 /// Key to a component. Type system somewhat ensures that there can only be one
 /// of these. Only with a key one may retrieve privately-accessible memory for
 /// a component. Practically just a generational index, like `CompId` is.
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub(crate) struct CompKey(pub u32);
 impl CompKey {
     pub(crate) fn downgrade(&self) -> CompId {
         return CompId(self.0);
+    }
+}
 /// Generational ID of a component
+/// Generational ID of a component.
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub struct CompId(pub u32);
 impl CompId {
     pub(crate) fn new_invalid() -> CompId {
         return CompId(u32::MAX);
+    }
     /// Upgrade component ID to component key. Unsafe because the caller needs
     /// to make sure that only one component key can exist at a time (to ensure
     /// a component can only be scheduled/executed by one thread).
     pub(crate) unsafe fn upgrade(&self) -> CompKey {
         return CompKey(self.0);
+    }
+}
 /// Handle to a component that is being created.
 pub(crate) struct CompReserved {
     reservation: ComponentReservation,
+}
 impl CompReserved {
     pub(crate) fn id(&self) -> CompId {
         return CompId(self.reservation.index)
+    }
+}
 /// Representation of a runtime component. Contains the bookkeeping variables
 /// for the schedulers, the publicly accessible fields, and the private fields
 /// that should only be accessed by the thread running the component's routine.
 pub(crate) struct RuntimeComp {
     pub public: CompPublic,
     pub component: Box<dyn Component>,
     pub ctx: CompCtx,
     pub inbox: QueueDynMpsc<Message>,
     pub exiting: bool,
+}
 /// Should contain everything that is accessible in a thread-safe manner
 // TODO: Do something about the `num_handles` thing. This needs to be a bit more
 //  "foolproof" to lighten the mental burden of using the `num_handles`
 //  variable.
 pub(crate) struct CompPublic {
     pub sleeping: AtomicBool,
     pub num_handles: AtomicU32, // manually modified (!)
     inbox: QueueDynProducer<Message>,
+}
 /// Handle to public part of a component. Would be nice if we could
 /// automagically manage the `num_handles` counter. But when it reaches zero we
 /// need to manually remove the handle from the runtime. So we just have debug
 /// code to make sure this actually happens.
 pub(crate) struct CompHandle {
     target: *const CompPublic,
-    id: CompId, // TODO: @Remove after debugging
     id: CompId,
     #[cfg(debug_assertions)] decremented: bool,
+}
 impl CompHandle {
     fn new(id: CompId, public: &CompPublic) -> CompHandle {
         let handle = CompHandle{
             target: public,
             id,
             #[cfg(debug_assertions)] decremented: false,
         };
         handle.increment_users();
         return handle;
+    }
     pub(crate) fn send_message(&self, sched_ctx: &SchedulerCtx, message: Message, try_wake_up: bool) {
         sched_ctx.log(&format!("Sending message to [c:{:03}, wakeup:{}]: {:?}", self.id.0, try_wake_up, message));
     pub(crate) fn send_message(&self, runtime: &RuntimeInner, message: Message, try_wake_up: bool) {
         self.inbox.push(message);
         if try_wake_up {
-            wake_up_if_sleeping(sched_ctx, self.id, self);
+            wake_up_if_sleeping(runtime, self.id, self);
+        }
+    }
     pub(crate) fn id(&self) -> CompId {
         return self.id;
+    }
     fn increment_users(&self) {
         let old_count = self.num_handles.fetch_add(1, Ordering::AcqRel);
         debug_assert!(old_count > 0); // because we should never be able to retrieve a handle when the component is (being) destroyed
+    }
     /// Returns the `CompKey` to the component if it should be destroyed
     pub(crate) fn decrement_users(&mut self) -> Option<CompKey> {
         dbg_code!(assert!(!self.decremented, "illegal to 'decrement_users' twice"));
         let old_count = self.num_handles.fetch_sub(1, Ordering::AcqRel);
         let new_count = old_count - 1;
         dbg_code!(self.decremented = true);
         if new_count == 0 {
             return Some(unsafe{ self.id.upgrade() });
+        }
         return None;
+    }
+}
 impl Clone for CompHandle {
     fn clone(&self) -> Self {
         dbg_code!(assert!(!self.decremented, "illegal to clone after 'decrement_users'"));
         self.increment_users();
         return CompHandle{
             target: self.target,
             id: self.id,
             #[cfg(debug_assertions)] decremented: false,
         };
+    }
+}
 impl std::ops::Deref for CompHandle {
     type Target = CompPublic;
     fn deref(&self) -> &Self::Target {
         dbg_code!(assert!(!self.decremented)); // cannot access if control is relinquished
         return unsafe{ &*self.target };
+    }
+}
 impl Drop for CompHandle {
     fn drop(&mut self) {
         dbg_code!(assert!(self.decremented, "need call to 'decrement_users' before dropping"));
+    }
+}
 // -----------------------------------------------------------------------------
 // Runtime
 // -----------------------------------------------------------------------------
 pub struct Runtime {
     pub(crate) inner: Arc<RuntimeInner>,
     threads: Vec<std::thread::JoinHandle<()>>,
     scheduler_threads: Vec<thread::JoinHandle<()>>,
     polling_destroyer: PollingThreadDestroyer,
     polling_thread: Option<thread::JoinHandle<()>>,
+}
 impl Runtime {
     // TODO: debug_logging should be removed at some point
     pub fn new(num_threads: u32, debug_logging: bool, protocol_description: ProtocolDescription) -> Runtime {
         assert!(num_threads > 0, "need a thread to perform work");
     pub fn new(num_threads: u32, debug_logging: bool, protocol_description: ProtocolDescription) -> Result<Runtime, RtError> {
         if num_threads == 0 {
             return Err(rt_error!("need at least one thread to create the runtime"));
+        }
         let runtime_inner = Arc::new(RuntimeInner {
             protocol: protocol_description,
             components: ComponentStore::new(128),
             work_queue: Mutex::new(VecDeque::with_capacity(128)),
             work_condvar: Condvar::new(),
             active_elements: AtomicU32::new(1),
         });
         let mut runtime = Runtime {
             inner: runtime_inner,
             threads: Vec::with_capacity(num_threads as usize),
         };
         let polling_builder = rt_error_try!(
             PollingThreadBuilder::new(runtime_inner.clone(), debug_logging),
             "failed to build polling thread"
         );
         let mut scheduler_threads = Vec::with_capacity(num_threads as usize);
         for thread_index in 0..num_threads {
             let mut scheduler = Scheduler::new(runtime.inner.clone(), thread_index, debug_logging);
             let thread_handle = std::thread::spawn(move || {
             let mut scheduler = Scheduler::new(
                 runtime_inner.clone(), polling_builder.client(),
                 thread_index, debug_logging
             );
             let thread_handle = thread::spawn(move || {
                 scheduler.run();
             });
-            runtime.threads.push(thread_handle);
+            scheduler_threads.push(thread_handle);
+        }
         return runtime;
         let (mut poller, polling_destroyer) = polling_builder.into_thread();
         let polling_thread = thread::spawn(move || {
             poller.run();
         });
         return Ok(Runtime{
             inner: runtime_inner,
             scheduler_threads,
             polling_destroyer,
             polling_thread: Some(polling_thread),
         });
+    }
     pub fn create_component(&self, module_name: &[u8], routine_name: &[u8]) -> Result<(), ComponentCreationError> {
         use crate::protocol::eval::ValueGroup;
         let prompt = self.inner.protocol.new_component(
             module_name, routine_name,
             ValueGroup::new_stack(Vec::new())
         )?;
         let reserved = self.inner.start_create_pdl_component();
         let ctx = CompCtx::new(&reserved);
         let component = Box::new(CompPDL::new(prompt, 0));
         let (key, _) = self.inner.finish_create_pdl_component(reserved, component, ctx, false);
         self.inner.enqueue_work(key);
         return Ok(())
+    }
+}
 impl Drop for Runtime {
     fn drop(&mut self) {
         self.inner.decrement_active_components();
-        for handle in self.threads.drain(..) {
+        for handle in self.scheduler_threads.drain(..) {
             handle.join().expect("join scheduler thread");
+        }
         self.polling_destroyer.initiate_destruction();
         self.polling_thread.take().unwrap().join().expect("join polling thread");
+    }
+}
 /// Memory that is maintained by "the runtime". In practice it is maintained by
 /// multiple schedulers, and this serves as the common interface to that memory.
 pub(crate) struct RuntimeInner {
     pub protocol: ProtocolDescription,
     components: ComponentStore<RuntimeComp>,
     work_queue: Mutex<VecDeque<CompKey>>,
     work_condvar: Condvar,
     active_elements: AtomicU32, // active components and APIs (i.e. component creators)
+}
 impl RuntimeInner {
     // Scheduling and retrieving work
     pub(crate) fn take_work(&self) -> Option<CompKey> {
         let mut lock = self.work_queue.lock().unwrap();
         while lock.is_empty() && self.active_elements.load(Ordering::Acquire) != 0 {
             lock = self.work_condvar.wait(lock).unwrap();
+        }
         // We have work, or the schedulers should exit.
         return lock.pop_front();
+    }
     pub(crate) fn enqueue_work(&self, key: CompKey) {
         let mut lock = self.work_queue.lock().unwrap();
         lock.push_back(key);
         self.work_condvar.notify_one();
+    }
     // Creating/destroying components
     pub(crate) fn start_create_pdl_component(&self) -> CompReserved {
         self.increment_active_components();
         let reservation = self.components.reserve();
         return CompReserved{ reservation };
+    }
     pub(crate) fn finish_create_pdl_component(
         &self, reserved: CompReserved,
         component: Box<dyn Component>, mut context: CompCtx, initially_sleeping: bool,
     ) -> (CompKey, &mut RuntimeComp) {
         let inbox_queue = QueueDynMpsc::new(16);
         let inbox_producer = inbox_queue.producer();
         let _id = reserved.id();
         context.id = reserved.id();
         let component = RuntimeComp {
             public: CompPublic{
                 sleeping: AtomicBool::new(initially_sleeping),
                 num_handles: AtomicU32::new(1), // the component itself acts like a handle
                 inbox: inbox_producer,
             },
             component,
             ctx: context,
             inbox: inbox_queue,
             exiting: false,
         };
         let index = self.components.submit(reserved.reservation, component);
         debug_assert_eq!(index, _id.0);
         let component = self.components.get_mut(index);
         return (CompKey(index), component);
+    }
     pub(crate) fn get_component(&self, key: CompKey) -> &mut RuntimeComp {
         let component = self.components.get_mut(key.0);
         return component;
+    }
     pub(crate) fn get_component_public(&self, id: CompId) -> CompHandle {
         let component = self.components.get(id.0);
         return CompHandle::new(id, &component.public);
+    }
     pub(crate) fn destroy_component(&self, key: CompKey) {
         dbg_code!({
             let component = self.get_component(key);
             debug_assert!(component.exiting);
             debug_assert_eq!(component.public.num_handles.load(Ordering::Acquire), 0);
         });
         self.decrement_active_components();
         self.components.destroy(key.0);
+    }
     // Tracking number of active interfaces and the active components
     #[inline]
     fn increment_active_components(&self) {
         let _old_val = self.active_elements.fetch_add(1, Ordering::AcqRel);
         debug_assert!(_old_val > 0); // can only create a component from a API/component, so can never be 0.
+    }
     fn decrement_active_components(&self) {
         let old_val = self.active_elements.fetch_sub(1, Ordering::AcqRel);
         debug_assert!(old_val > 0); // something wrong with incr/decr logic
         let new_val = old_val - 1;
         if new_val == 0 {
             // Just to be sure, in case the last thing that gets destroyed is an
             // API instead of a thread.
             let _lock = self.work_queue.lock();
             self.work_condvar.notify_all();
+        }
+    }
+}

src/runtime2/scheduler.rs

➞

Show inline comments

 use std::sync::Arc;
 use std::sync::atomic::Ordering;
 use crate::runtime2::poll::PollingClient;
 use super::component::*;
 use super::runtime::*;
 /// Data associated with a scheduler thread
 pub(crate) struct Scheduler {
     runtime: Arc<RuntimeInner>,
     polling: PollingClient,
     scheduler_id: u32,
     debug_logging: bool,
+}
 pub(crate) struct SchedulerCtx<'a> {
     pub runtime: &'a RuntimeInner,
     pub polling: &'a PollingClient,
     pub id: u32,
     pub comp: u32,
     pub logging_enabled: bool,
+}
 impl<'a> SchedulerCtx<'a> {
     pub fn new(runtime: &'a RuntimeInner, id: u32, logging_enabled: bool) -> Self {
+    pub fn new(runtime: &'a RuntimeInner, polling: &'a PollingClient, id: u32, logging_enabled: bool) -> Self {
         return Self {
             runtime,
             polling,
             id,
             comp: 0,
             logging_enabled,
+        }
+    }
     pub(crate) fn log(&self, text: &str) {
         if self.logging_enabled {
             println!("[s:{:02}, c:{:03}] {}", self.id, self.comp, text);
+        }
+    }
+}
 impl Scheduler {
     // public interface to thread
     pub fn new(runtime: Arc<RuntimeInner>, scheduler_id: u32, debug_logging: bool) -> Self {
         return Scheduler{ runtime, scheduler_id, debug_logging }
     pub fn new(runtime: Arc<RuntimeInner>, polling: PollingClient, scheduler_id: u32, debug_logging: bool) -> Self {
         return Scheduler{ runtime, polling, scheduler_id, debug_logging }
+    }
     pub fn run(&mut self) {
         let mut scheduler_ctx = SchedulerCtx::new(&*self.runtime, self.scheduler_id, self.debug_logging);
+        let mut scheduler_ctx = SchedulerCtx::new(&*self.runtime, &self.polling, self.scheduler_id, self.debug_logging);
         'run_loop: loop {
             // Wait until we have something to do (or need to quit)
             let comp_key = self.runtime.take_work();
             if comp_key.is_none() {
                 break 'run_loop;
+            }
             let comp_key = comp_key.unwrap();
             let component = self.runtime.get_component(comp_key);
             scheduler_ctx.comp = comp_key.0;
             // Run the component until it no longer indicates that it needs to
             // be re-executed immediately.
             let mut new_scheduling = CompScheduling::Immediate;
             while let CompScheduling::Immediate = new_scheduling {
                 while let Some(message) = component.inbox.pop() {
                     component.component.handle_message(&mut scheduler_ctx, &mut component.ctx, message);
+                }
                 new_scheduling = component.component.run(&mut scheduler_ctx, &mut component.ctx).expect("TODO: Handle error");
+            }
             // Handle the new scheduling
             match new_scheduling {
                 CompScheduling::Immediate => unreachable!(),
                 CompScheduling::Requeue => { self.runtime.enqueue_work(comp_key); },
                 CompScheduling::Sleep => { self.mark_component_as_sleeping(comp_key, component); },
                 CompScheduling::Exit => { self.mark_component_as_exiting(&scheduler_ctx, component); }
+            }
+        }
+    }
     // local utilities
     /// Marks component as sleeping, if after marking itself as sleeping the
     /// inbox contains messages then the component will be immediately
     /// rescheduled. After calling this function the component should not be
     /// executed anymore.
     fn mark_component_as_sleeping(&self, key: CompKey, component: &mut RuntimeComp) {
         debug_assert_eq!(key.downgrade(), component.ctx.id); // make sure component matches key
         debug_assert_eq!(component.public.sleeping.load(Ordering::Acquire), false); // we're executing it, so it cannot be sleeping
         component.public.sleeping.store(true, Ordering::Release);
         if component.inbox.can_pop() {
             let should_reschedule = component.public.sleeping
                 .compare_exchange(true, false, Ordering::AcqRel, Ordering::Relaxed)
                 .is_ok();
             if should_reschedule {
                 self.runtime.enqueue_work(key);
+            }
+        }
+    }
     /// Marks the component as exiting by removing the reference it holds to
     /// itself. Afterward the component will enter "normal" sleeping mode (if it
     /// has not yet been destroyed)
     fn mark_component_as_exiting(&self, sched_ctx: &SchedulerCtx, component: &mut RuntimeComp) {
         // If we didn't yet decrement our reference count, do so now
         let comp_key = unsafe{ component.ctx.id.upgrade() };
         if !component.exiting {
             component.exiting = true;
             let old_count = component.public.num_handles.fetch_sub(1, Ordering::AcqRel);
             let new_count = old_count - 1;
             if new_count == 0 {
                 sched_ctx.runtime.destroy_component(comp_key);
                 return;
+            }
+        }
         // Enter "regular" sleeping mode
         self.mark_component_as_sleeping(comp_key, component);
+    }
+}
@@ \ No newline at end of file @@

src/runtime2/stdlib/internet.rs

➞

Show inline comments

 use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
 use std::mem::size_of;
 use libc::{
     c_int,
     sockaddr_in, sockaddr_in6, in_addr, in6_addr,
     socket, bind, listen, accept, connect, close,
 };
 use mio::{event, Interest, Registry, Token};
 #[derive(Debug)]
 pub enum SocketError {
     Opening,
     Modifying,
     Binding,
     Listening,
     Connecting,
     Accepted,
     Accepting,
+}
 enum SocketState {
     Opened,
     Listening,
+}
 /// TCP connection
 pub struct SocketTcpClient {
     socket_handle: libc::c_int,
     is_blocking: bool,
+}
 impl SocketTcpClient {
     pub fn new(ip: IpAddr, port: u16) -> Result<Self, SocketError> {
         const BLOCKING: bool = false;
         let socket_handle = create_and_connect_socket(
             libc::SOCK_STREAM, libc::IPPROTO_TCP, ip, port
         )?;
         if !set_socket_blocking(socket_handle, BLOCKING) {
             unsafe{ libc::close(socket_handle); }
             return Err(SocketError::Modifying);
+        }
         return Ok(SocketTcpClient{
             socket_handle,
             is_blocking: BLOCKING,
         })
+    }
     pub fn send(&self, message: &[u8]) -> Result<usize, ()> {
         let result = unsafe{
             let message_pointer = message.as_ptr().cast();
             libc::send(self.socket_handle, message_pointer, message.len() as libc::size_t, 0)
         };
         if result < 0 {
             return Err(())
+        }
         return Ok(result as usize);
+    }
     /// Receives data from the TCP socket. Returns the number of bytes received.
     /// More bytes may be present even thought `used < buffer.len()`.
     pub fn receive(&self, buffer: &mut [u8]) -> Result<usize, ()> {
         if self.is_blocking {
             return self.receive_blocking(buffer);
         } else {
             return self.receive_nonblocking(buffer);
+        }
+    }
     #[inline]
     fn receive_blocking(&self, buffer: &mut [u8]) -> Result<usize, ()> {
         let result = unsafe {
             let message_pointer = buffer.as_mut_ptr().cast();
             libc::recv(self.socket_handle, message_pointer, buffer.len(), 0)
         };
         if result < 0 {
             return Err(());
+        }
         return Ok(result as usize);
+    }
     #[inline]
     fn receive_nonblocking(&self, buffer: &mut [u8]) -> Result<usize, ()> {
         unsafe {
             let mut message_pointer = buffer.as_mut_ptr().cast();
             let mut remaining = buffer.len();
             loop {
                 // Receive more data
                 let result = libc::recv(self.socket_handle, message_pointer, remaining, 0);
                 if result < 0 {
                     // Check reason
                     let errno = std::io::Error::last_os_error().raw_os_error().expect("os error after failed recv");
                     if errno == libc::EWOULDBLOCK || errno == libc::EAGAIN {
                         return Ok(buffer.len() - remaining);
                     } else {
                         return Err(());
+                    }
+                }
                 // Modify pointer and remaining bytes
                 let received = result as usize;
                 message_pointer = message_pointer.add(received);
                 remaining -= received;
                 if remaining == 0 {
                     return Ok(buffer.len());
+                }
+            }
+        }
+    }
+}
 impl Drop for SocketTcpClient {
     fn drop(&mut self) {
         debug_assert!(self.socket_handle >= 0);
         unsafe{ close(self.socket_handle) };
+    }
+}
 /// Raw socket receiver. Essentially a listener that accepts a single connection
 struct SocketRawRx {
     listen_handle: c_int,
     accepted_handle: c_int,
+}
 impl SocketRawRx {
     pub fn new(ip: Option<Ipv4Addr>, port: u16) -> Result<Self, SocketError> {
         let ip = ip.unwrap_or(Ipv4Addr::UNSPECIFIED); // unspecified is the same as INADDR_ANY
         let address = unsafe{ in_addr{
             s_addr: std::mem::transmute(ip.octets()),
         }};
         let socket_address = sockaddr_in{
             sin_family: libc::AF_INET as libc::sa_family_t,
             sin_port: htons(port),
             sin_addr: address,
             sin_zero: [0; 8],
         };
         unsafe {
             let socket_handle = create_and_bind_socket(libc::SOCK_RAW, 0, IpAddr::V4(ip), port)?;
             let result = listen(socket_handle, 3);
             if result < 0 { return Err(SocketError::Listening); }
             return Ok(SocketRawRx{
                 listen_handle: socket_handle,
                 accepted_handle: -1,
             });
+        }
+    }
     // pub fn try_accept(&mut self, timeout_ms: u32) -> Result<(), SocketError> {
     //     if self.accepted_handle >= 0 {
     //         // Already accepted a connection
     //         return Err(SocketError::Accepted);
     //     }
     //
     //     let mut socket_address = sockaddr_in{
     //         sin_family: 0,
     //         sin_port: 0,
     //         sin_addr: in_addr{ s_addr: 0 },
     //         sin_zero: [0; 8]
     //     };
     //     let mut size = size_of::<sockaddr_in>() as u32;
     //     unsafe {
     //         let result = accept(self.listen_handle, &mut socket_address as *mut _, &mut size as *mut _);
     //         if result < 0 {
     //             return Err(SocketError::Accepting);
     //         }
     //     }
     //
     //     return Ok(());
     // }
+}
 impl Drop for SocketRawRx {
     fn drop(&mut self) {
         if self.accepted_handle >= 0 {
             unsafe {
                 close(self.accepted_handle);
+            }
+        }
         if self.listen_handle >= 0 {
             unsafe {
                 close(self.listen_handle);
+            }
+        }
+    }
+}
 // The following is essentially stolen from `mio`'s io_source.rs file.
 #[cfg(unix)]
 trait AsRawFileDescriptor {
     fn as_raw_file_descriptor(&self) -> c_int;
+}
 impl AsRawFileDescriptor for SocketTcpClient {
     fn as_raw_file_descriptor(&self) -> c_int {
         return self.socket_handle;
+    }
+}
 impl<T: AsRawFileDescriptor> event::Source for T {
     fn register(&mut self, registry: &Registry, token: Token, interests: Interest) -> std::io::Result<()> {
         registry.selector().register()
+    }
     fn reregister(&mut self, registry: &Registry, token: Token, interests: Interest) -> std::io::Result<()> {
         todo!()
+    }
     fn deregister(&mut self, registry: &Registry) -> std::io::Result<()> {
         todo!()
+    }
+}
 /// Performs the `socket` and `bind` calls.
 fn create_and_bind_socket(socket_type: libc::c_int, protocol: libc::c_int, ip: IpAddr, port: u16) -> Result<libc::c_int, SocketError> {
     let family = socket_family_from_ip(ip);
     unsafe {
         let socket_handle = socket(family, socket_type, protocol);
         if socket_handle < 0 {
             return Err(SocketError::Opening);
+        }
         let result = match ip {
             IpAddr::V4(ip) => {
                 let (socket_address, address_size) = create_sockaddr_in_v4(ip, port);
                 let socket_pointer = &socket_address as *const sockaddr_in;
                 bind(socket_handle, socket_pointer.cast(), address_size)
             },
             IpAddr::V6(ip) => {
                 let (socket_address, address_size) = create_sockaddr_in_v6(ip, port);
                 let socket_pointer= &socket_address as *const sockaddr_in6;
                 bind(socket_handle, socket_pointer.cast(), address_size)
+            }
         };
         if result < 0 {
             close(socket_handle);
             return Err(SocketError::Binding);
+        }
         return Ok(socket_handle);
+    }
+}
 /// Performs the `socket` and `connect` calls
 fn create_and_connect_socket(socket_type: libc::c_int, protocol: libc::c_int, ip: IpAddr, port: u16) -> Result<libc::c_int, SocketError> {
     let family = socket_family_from_ip(ip);
     unsafe {
         let socket_handle = socket(family, socket_type, protocol);
         if socket_handle < 0 {
             return Err(SocketError::Opening);
+        }
         let result = match ip {
             IpAddr::V4(ip) => {
                 let (socket_address, address_size) = create_sockaddr_in_v4(ip, port);
                 let socket_pointer = &socket_address as *const sockaddr_in;
                 connect(socket_handle, socket_pointer.cast(), address_size)
             },
             IpAddr::V6(ip) => {
                 let (socket_address, address_size) = create_sockaddr_in_v6(ip, port);
                 let socket_pointer= &socket_address as *const sockaddr_in6;
                 connect(socket_handle, socket_pointer.cast(), address_size)
+            }
         };
         if result < 0 {
             close(socket_handle);
             return Err(SocketError::Connecting);
+        }
         return Ok(socket_handle);
+    }
+}
 #[inline]
 fn create_sockaddr_in_v4(ip: Ipv4Addr, port: u16) -> (sockaddr_in, libc::socklen_t) {
     let address = unsafe{
         in_addr{
             s_addr: std::mem::transmute(ip.octets())
+        }
     };
     let socket_address = sockaddr_in{
         sin_family: libc::AF_INET as libc::sa_family_t,
         sin_port: htons(port),
         sin_addr: address,
         sin_zero: [0; 8]
     };
     let address_size = size_of::<sockaddr_in>();
     return (socket_address, address_size as _);
+}
 #[inline]
 fn create_sockaddr_in_v6(ip: Ipv6Addr, port: u16) -> (sockaddr_in6, libc::socklen_t) {
     // flow label is advised to be, according to RFC6437 a (somewhat
     // secure) random number taken from a uniform distribution
     let flow_info = rand::random();
     let address = unsafe{
         in6_addr{
             s6_addr: ip.octets()
+        }
     };
     let socket_address = sockaddr_in6{
         sin6_family: libc::AF_INET6 as libc::sa_family_t,
         sin6_port: htons(port),
         sin6_flowinfo: flow_info,
         sin6_addr: address,
         sin6_scope_id: 0, // incorrect in case of loopback address
     };
     let address_size = size_of::<sockaddr_in6>();
     return (socket_address, address_size as _);
+}
 #[inline]
 fn set_socket_blocking(handle: libc::c_int, blocking: bool) -> bool {
     if handle < 0 {
         return false;
+    }
     unsafe{
         let mut flags = libc::fcntl(handle, libc::F_GETFL, 0);
         if flags < 0 {
             return false;
+        }
         if blocking {
             flags &= !libc::O_NONBLOCK;
         } else {
             flags |= libc::O_NONBLOCK;
+        }
         let result = libc::fcntl(handle, libc::F_SETFL, flags);
         if result < 0 {
             return false;
+        }
+    }
     return true;
+}
 #[inline]
 fn socket_family_from_ip(ip: IpAddr) -> libc::c_int {
     return match ip {
         IpAddr::V4(_) => libc::AF_INET,
         IpAddr::V6(_) => libc::AF_INET6,
     };
+}
 #[inline]
 fn htons(port: u16) -> u16 {
     return port.to_be();
+}
 mod tests {
     use std::net::*;
     use super::*;
     #[test]
     fn test_inet_thingo() {
         const SIZE: usize = 1024;
         let s = SocketTcpClient::new(IpAddr::V4(Ipv4Addr::new(142, 250, 179, 163)), 80).expect("connect");
         s.send(b"GET / HTTP/1.1\r\n\r\n").expect("sending");
         let mut total = Vec::<u8>::new();
         let mut buffer = [0; SIZE];
         let mut received = SIZE;
         while received > 0 {
             received = s.receive(&mut buffer).expect("receiving");
             println!("DEBUG: Received {} bytes", received);
             total.extend_from_slice(&buffer[..received]);
+        }
         let as_str = String::from_utf8_lossy(total.as_slice());
         println!("Yay! Got {} bytes:\n{}", as_str.len(), as_str);
+    }
+}
@@ \ No newline at end of file @@

src/runtime2/store/queue_mpsc.rs

➞

Show inline comments

 use std::sync::atomic::{AtomicU32, Ordering};
 use crate::collections::RawArray;
 use super::unfair_se_lock::{UnfairSeLock, UnfairSeLockSharedGuard};
 /// Multiple-producer single-consumer queue. Generally used in the publicly
 /// accessible fields of a component. The holder of this struct should be the
 /// consumer. To retrieve access to the producer-side: call `producer()`.
 ///
 /// This is a queue that will resize (indefinitely) if it becomes full, and will
 /// not shrink. So probably a temporary thing.
 ///
 /// In debug mode we'll make sure that there are no producers when the queue is
 /// dropped. We don't do this in release mode because the runtime is written
 /// such that components always remain alive (hence, this queue will remain
 /// accessible) while there are references to it.
 // NOTE: Addendum to the above remark, not true if the thread owning the
 // consumer sides crashes, unwinds, and drops the `Box` with it. Question is: do
 // I want to take that into account?
 pub struct QueueDynMpsc<T> {
     // Entire contents are boxed up such that we can create producers that have
     // a pointer to the contents.
     inner: Box<Shared<T>>
+}
 // One may move around the queue between threads, as long as there is only one
 // instance of it.
 unsafe impl<T> Send for QueueDynMpsc<T>{}
 /// Shared data between queue consumer and the queue producers
 struct Shared<T> {
     data: UnfairSeLock<Inner<T>>,
     read_head: AtomicU32,
     write_head: AtomicU32,
     limit_head: AtomicU32,
     #[cfg(debug_assertions)] dbg: AtomicU32,
+}
 /// Locked by an exclusive/shared lock. Exclusive lock is obtained when the
 /// inner data array is resized.
 struct Inner<T> {
     data: RawArray<T>,
     compare_mask: u32,
     read_mask: u32,
+}
 type InnerRead<'a, T> = UnfairSeLockSharedGuard<'a, Inner<T>>;
 impl<T> QueueDynMpsc<T> {
     /// Constructs a new MPSC queue. Note that the initial capacity is always
     /// increased to the next power of 2 (if it isn't already).
     pub fn new(initial_capacity: usize) -> Self {
         let initial_capacity = initial_capacity.next_power_of_two();
         assert_correct_capacity(initial_capacity);
         let mut data = RawArray::new();
         data.resize(initial_capacity);
         let initial_capacity = initial_capacity as u32;
         return Self{
             inner: Box::new(Shared {
                 data: UnfairSeLock::new(Inner{
                     data,
                     compare_mask: (2 * initial_capacity) - 1,
                     read_mask: initial_capacity - 1,
                 }),
                 read_head: AtomicU32::new(0),
                 write_head: AtomicU32::new(initial_capacity),
                 limit_head: AtomicU32::new(initial_capacity),
                 #[cfg(debug_assertions)] dbg: AtomicU32::new(0),
             }),
         };
+    }
     #[inline]
     pub fn producer(&self) -> QueueDynProducer<T> {
         return QueueDynProducer::new(self);
+    }
     /// Return `true` if a subsequent call to `pop` will return a value. Note
     /// that if it returns `false`, there *might* also be a value returned by
     /// `pop`.
     pub fn can_pop(&mut self) -> bool {
         let data_lock = self.inner.data.lock_shared();
         let cur_read = self.inner.read_head.load(Ordering::Acquire);
         let cur_limit = self.inner.limit_head.load(Ordering::Acquire);
         let buf_size = data_lock.data.cap() as u32;
         return (cur_read + buf_size) & data_lock.compare_mask != cur_limit;
+    }
     /// Perform an attempted read from the queue. It might be that some producer
     /// is putting something in the queue while this function is executing, and
     /// we don't get the consume it.
     pub fn pop(&mut self) -> Option<T> {
         let data_lock = self.inner.data.lock_shared();
         let cur_read = self.inner.read_head.load(Ordering::Acquire);
         let cur_limit = self.inner.limit_head.load(Ordering::Acquire);
         let buf_size = data_lock.data.cap() as u32;
         if (cur_read + buf_size) & data_lock.compare_mask != cur_limit {
             // Make a bitwise copy of the value and return it. The receiver is
             // responsible for dropping it.
             unsafe {
                 let source = data_lock.data.get((cur_read & data_lock.read_mask) as usize);
                 let value = std::ptr::read(source);
                 // We can perform a store since we're the only ones modifying
                 // the atomic.
                 self.inner.read_head.store((cur_read + 1) & data_lock.compare_mask, Ordering::Release);
                 return Some(value);
+            }
         } else {
             return None;
+        }
+    }
+}
 impl<T> Drop for QueueDynMpsc<T> {
     fn drop(&mut self) {
         // There should be no more `QueueDynProducer` pointers to this queue
         dbg_code!(assert_eq!(self.inner.dbg.load(Ordering::Acquire), 0));
         // And so the limit head should be equal to the write head
         let data_lock = self.inner.data.lock_shared();
         let write_index = self.inner.write_head.load(Ordering::Acquire);
         assert_eq!(self.inner.limit_head.load(Ordering::Acquire), write_index);
         // Every item that has not yet been taken out of the queue needs to
         // have its destructor called. We immediately apply the
         // increment-by-size trick and wait until we've hit the write head.
         let mut read_index = self.inner.read_head.load(Ordering::Acquire);
         read_index += data_lock.data.cap() as u32;
         while read_index & data_lock.compare_mask != write_index {
             unsafe {
                 let target = data_lock.data.get((read_index & data_lock.read_mask) as usize);
                 std::ptr::drop_in_place(target);
+            }
             read_index += 1;
+        }
+    }
+}
 pub struct QueueDynProducer<T> {
     queue: *const Shared<T>,
+}
 impl<T> QueueDynProducer<T> {
     fn new(consumer: &QueueDynMpsc<T>) -> Self {
         dbg_code!(consumer.inner.dbg.fetch_add(1, Ordering::AcqRel));
         unsafe {
             // If you only knew the power of the dark side! Obi-Wan never told
             // you what happened to your father!
-            let queue: *const _ = std::mem::transmute(consumer.inner.as_ref());
+            let queue = consumer.inner.as_ref() as *const _;
             return Self{ queue };
+        }
+    }
     pub fn push(&self, value: T) {
         let queue = unsafe{ &*self.queue };
         let mut data_lock = queue.data.lock_shared();
         let mut write_index = queue.write_head.load(Ordering::Acquire);
         'attempt_write: loop {
             let read_index = queue.read_head.load(Ordering::Acquire);
             if write_index == read_index { // both stored as [0, 2*capacity), so we can check equality without bitwise ANDing
                 // Need to resize, try loading read/write index afterwards
                 let expected_capacity = data_lock.data.cap();
                 data_lock = self.resize(data_lock, expected_capacity);
                 write_index = queue.write_head.load(Ordering::Acquire);
                 continue 'attempt_write;
+            }
             // If here try to advance write index
             let new_write_index = (write_index + 1) & data_lock.compare_mask;
             if let Err(actual_write_index) = queue.write_head.compare_exchange(
                 write_index, new_write_index, Ordering::AcqRel, Ordering::Acquire
             ) {
                 write_index = actual_write_index;
                 continue 'attempt_write;
+            }
             // We're now allowed to write at `write_index`
             unsafe {
                 std::ptr::write(data_lock.data.get((write_index & data_lock.read_mask) as usize), value);
+            }
             // Update limit head to let reader obtain the written value in a
             // CAS-loop
             while let Err(_) = queue.limit_head.compare_exchange_weak(
                 write_index, new_write_index,
                 Ordering::AcqRel, Ordering::Relaxed
             ) {}
             return;
+        }
+    }
     fn resize(&self, shared_lock: InnerRead<T>, expected_capacity: usize) -> InnerRead<T> {
         drop(shared_lock);
         let queue = unsafe{ &*self.queue };
+        {
             let mut exclusive_lock = queue.data.lock_exclusive();
             // We hold the exclusive lock, but someone else might have done the resizing, and so:
             if exclusive_lock.data.cap() == expected_capacity {
                 let old_capacity = expected_capacity;
                 let new_capacity = 2 * old_capacity;
                 assert_correct_capacity(new_capacity);
                 // Resize by a factor of two, and make the two halves identical.
                 exclusive_lock.data.resize(new_capacity);
                 for idx in old_capacity..new_capacity {
                     unsafe {
                         let target = exclusive_lock.data.get(idx);
                         let source = exclusive_lock.data.get(idx - old_capacity);
                         std::ptr::write(target, std::ptr::read(source));
+                    }
+                }
                 // Modify all atomics to reflect that we just resized the
                 // underlying buffer. We have that everything between the read
                 // index and the write index is readable. And the following
                 // preserves that property, while increasing the size from
                 // `old_capacity` to `new_capacity`.
                 // Note that the addition of `new_capacity` to `write_head` is
                 // to ensure the ringbuffer can distinguish the cases where the
                 // ringbuffer is full, and when it is empty.
                 let mut read_index = queue.read_head.load(Ordering::Acquire);
                 let mut write_index = queue.write_head.load(Ordering::Acquire);
                 debug_assert_eq!(write_index, queue.limit_head.load(Ordering::Acquire)); // since we have exclusive access
                 let is_full = read_index == write_index; // before bitwise AND-mask
                 read_index &= exclusive_lock.read_mask;
                 write_index &= exclusive_lock.read_mask;
                 let new_capacity = new_capacity as u32;
                 if read_index <= write_index && !is_full { // which means: (read index < write_index) || buffer_is_empty
                     // The readable elements do not wrap around the ringbuffer
                     write_index += new_capacity;
                 } else {
                     // The readable elements do wrap around the ringbuffer
                     write_index += old_capacity as u32;
                     write_index += new_capacity;
+                }
                 queue.read_head.store(read_index, Ordering::Release);
                 queue.limit_head.store(write_index, Ordering::Release);
                 queue.write_head.store(write_index, Ordering::Release);
                 // Update the masks
                 exclusive_lock.read_mask = new_capacity - 1;
                 exclusive_lock.compare_mask = (2 * new_capacity) - 1;
+            }
+        }
         // Reacquire shared lock
         return queue.data.lock_shared();
+    }
+}
 impl<T> Drop for QueueDynProducer<T> {
     fn drop(&mut self) {
         dbg_code!(unsafe{ (*self.queue).dbg.fetch_sub(1, Ordering::AcqRel) });
+    }
+}
 // producer end is `Send`, because in debug mode we make sure that there are no
 // more producers when the queue is destroyed. But is not sync, because that
 // would circumvent our atomic counter shenanigans. Although, now that I think
 // about it, we're rather likely to just drop a single "producer" into the
 // public part of a component.
 unsafe impl<T> Send for QueueDynProducer<T>{}
 #[inline]
 fn assert_correct_capacity(capacity: usize) {
     assert!(capacity.is_power_of_two() && capacity < (u32::MAX as usize) / 2);
+}
 #[cfg(test)]
 mod tests {
     use super::*;
     use super::super::tests::*;
     fn queue_size<T>(queue: &QueueDynMpsc<T>) -> usize {
         let lock = queue.inner.data.lock_exclusive();
         return lock.data.cap();
+    }
     #[test]
     fn single_threaded_fixed_size_push_pop() {
         const INIT_SIZE: usize = 16;
         const NUM_ROUNDS: usize = 3;
         let mut cons = QueueDynMpsc::new(INIT_SIZE);
         let prod = cons.producer();
         let counters = Counters::new();
         for _round in 0..NUM_ROUNDS {
             // Fill up with indices
             for idx in 0..INIT_SIZE {
                 prod.push(Resource::new(&counters, idx as u64));
+            }
             // Take out indices and check
             for idx in 0..INIT_SIZE {
                 let gotten = cons.pop().unwrap();
                 assert_eq!(idx as u64, gotten.val);
+            }
             assert!(cons.pop().is_none()); // nothing left in queue
             assert_eq!(queue_size(&cons), INIT_SIZE); // queue still of same size
+        }
         let num_expected = (INIT_SIZE * NUM_ROUNDS) as u64;
         assert_ctor_eq!(counters, num_expected);
         assert_dtor_eq!(counters, num_expected);
+    }
     #[test]
     fn single_threaded_resizing_push_pop() {
         const INIT_SIZE: usize = 8;
         const NUM_RESIZE: usize = 3; // note: each resize increases capacity by factor of two
         let mut cons = QueueDynMpsc::new(INIT_SIZE);
         let prod = cons.producer();
         let counters = Counters::new();
         for resize_idx in 0..NUM_RESIZE {
             // Fill up with indices, one more than the size
             let cur_size = INIT_SIZE << resize_idx;
             let new_size = cur_size << 1;
             for idx in 0..new_size {
                 prod.push(Resource::new(&counters, idx as u64));
+            }
             for idx in 0..new_size {
                 let gotten = cons.pop().unwrap();
                 assert_eq!(idx as u64, gotten.val);
+            }
             assert!(cons.pop().is_none());
             assert_eq!(queue_size(&cons), new_size);
+        }
         assert_eq!(queue_size(&cons), INIT_SIZE << NUM_RESIZE);
         // Bit trickery supremo (fails if INIT_SIZE is not a power of two)!
         let num_expected = ((INIT_SIZE << (NUM_RESIZE + 1)) - 1 - ((INIT_SIZE << 1) - 1)) as u64;
         assert_ctor_eq!(counters, num_expected);
         assert_dtor_eq!(counters, num_expected);
+    }
     #[test]
     fn single_threaded_alternating_push_pop() {
         const INIT_SIZE: usize = 32;
         const NUM_ROUNDS: usize = 4;
         const NUM_PROD: usize = 4;
         assert!(INIT_SIZE % NUM_PROD == 0);
         let mut cons = QueueDynMpsc::new(INIT_SIZE);
         let mut prods = Vec::with_capacity(NUM_PROD);
         for _ in 0..NUM_PROD {
             prods.push(cons.producer());
+        }
         let counters = Counters::new();
         for _round_idx in 0..NUM_ROUNDS {
             // Fill up, alternating per producer
             let mut prod_idx = 0;
             for idx in 0..INIT_SIZE {
                 let prod = &prods[prod_idx];
                 prod_idx += 1;
                 prod_idx %= NUM_PROD;
                 prod.push(Resource::new(&counters, idx as u64));
+            }
             // Retrieve and check again
             for idx in 0..INIT_SIZE {
                 let gotten = cons.pop().unwrap();
                 assert_eq!(idx as u64, gotten.val);
+            }
             assert!(cons.pop().is_none());
             assert_eq!(queue_size(&cons), INIT_SIZE);
+        }
         let num_expected = (NUM_ROUNDS * INIT_SIZE) as u64;
         assert_ctor_eq!(counters, num_expected);
         assert_dtor_eq!(counters, num_expected);
+    }
     #[test]
     fn partially_filled_cleanup() {
         // Init at 16, fill until 8, take out 4, 4 destructors not called before
         // queue consumer side is dropped
         let mut cons = QueueDynMpsc::new(16);
         let mut prod = cons.producer();
         let counters = Counters::new();
         for _ in 0..8 {
             prod.push(Resource::new(&counters, 0));
+        }
         for _ in 0..4 {
             cons.pop().expect("a value");
+        }
         assert_ctor_eq!(counters, 8);
         assert_dtor_eq!(counters, 4);
         drop(prod);
         drop(cons);
         assert_ctor_eq!(counters, 8);
         assert_dtor_eq!(counters, 8);
+    }
     #[test]
     fn multithreaded_production_and_consumption() {
         use std::sync::{Arc, Mutex};
         // Rather randomized test. Kind of a stress test. We let the producers
         // produce `u64` values with the high bits containing their identifier.
         // The consumer will try receive as fast as possible until each thread
         // has produced the expected number of values.
         const NUM_STRESS_TESTS: usize = 2;
         const NUM_PER_THREAD: usize = 4096;
         const NUM_PROD_THREADS: usize = 4;
         fn take_num_thread_idx(number: u64) -> u64 { return (number >> 32) & 0xFFFFFFFF; }
         fn take_num(number: u64) -> u64 { return number & 0xFFFFFFFF; }
         // Span queue and producers
         for _stress_idx in 0..NUM_STRESS_TESTS {
             let mut queue = QueueDynMpsc::<Resource>::new(4);
             let mut producers = Vec::with_capacity(NUM_PROD_THREADS);
             for _idx in 0..NUM_PROD_THREADS {
                 producers.push(queue.producer());
+            }
             let counters = Counters::new();
             // Start up consume thread and let it spin immediately. Note that it
             // must die last.
             let can_exit_lock = Arc::new(Mutex::new(false));
             let mut held_exit_lock = can_exit_lock.lock().unwrap();
             let consume_handle = {
                 let can_exit_lock = can_exit_lock.clone();
                 std::thread::spawn(move || {
                     let mut thread_val_counters = [0u64; NUM_PROD_THREADS];
                     let mut num_done = 0;
                     while num_done != NUM_PROD_THREADS {
                         // Spin until we get something
                         let new_value = loop {
                             if let Some(value) = queue.pop() {
                                 break value.val;
+                            }
                         };
                         let thread_idx = take_num_thread_idx(new_value);
                         let counter = &mut thread_val_counters[thread_idx as usize];
                         assert_eq!(*counter, take_num(new_value)); // values per thread arrive in order
                         *counter += 1;
                         if *counter == NUM_PER_THREAD as u64 {
                             // Finished this one
                             num_done += 1;
+                        }
+                    }
                     let _exit_guard = can_exit_lock.lock().unwrap();
                 })
             };
             // Set up producer threads
             let mut handles = Vec::with_capacity(NUM_PROD_THREADS);
             for prod_idx in 0..NUM_PROD_THREADS {
                 let prod_handle = producers.pop().unwrap();
                 let counters = counters.clone();
                 let handle = std::thread::spawn(move || {
                     let base_value = (prod_idx as u64) << 32;
                     for number in 0..NUM_PER_THREAD as u64 {
                         prod_handle.push(Resource::new(&counters, base_value + number));
+                    }
                 });
                 handles.push(handle);
+            }
             // Wait until all producers finished, then we unlock our held lock and
             // we wait until the consumer finishes
             for handle in handles {
                 handle.join().expect("clean producer exit");
+            }
             drop(held_exit_lock);
             consume_handle.join().expect("clean consumer exit");
             let num_expected = (NUM_PER_THREAD * NUM_PROD_THREADS) as u64;
             assert_ctor_eq!(counters, num_expected);
             assert_dtor_eq!(counters, num_expected);
+        }
+    }
+}
@@ \ No newline at end of file @@

src/runtime2/tests/mod.rs

➞

Show inline comments

 use crate::protocol::*;
 use crate::protocol::eval::*;
 use crate::runtime2::runtime::*;
 use crate::runtime2::component::{CompCtx, CompPDL};
 fn create_component(rt: &Runtime, module_name: &str, routine_name: &str, args: ValueGroup) {
     let prompt = rt.inner.protocol.new_component(
         module_name.as_bytes(), routine_name.as_bytes(), args
     ).expect("create prompt");
     let reserved = rt.inner.start_create_pdl_component();
     let ctx = CompCtx::new(&reserved);
     let component = Box::new(CompPDL::new(prompt, 0));
     let (key, _) = rt.inner.finish_create_pdl_component(reserved, component, ctx, false);
     rt.inner.enqueue_work(key);
+}
 fn no_args() -> ValueGroup { ValueGroup::new_stack(Vec::new()) }
 #[test]
 fn test_component_creation() {
     let pd = ProtocolDescription::parse(b"
     primitive nothing_at_all() {
         s32 a = 5;
         auto b = 5 + a;
+    }
     ").expect("compilation");
     let rt = Runtime::new(1, true, pd);
+    let rt = Runtime::new(1, true, pd).unwrap();
     for _i in 0..20 {
         create_component(&rt, "", "nothing_at_all", no_args());
+    }
+}
 #[test]
 fn test_component_communication() {
     let pd = ProtocolDescription::parse(b"
     primitive sender(out<u32> o, u32 outside_loops, u32 inside_loops) {
         u32 outside_index = 0;
         while (outside_index < outside_loops) {
             u32 inside_index = 0;
             sync while (inside_index < inside_loops) {
                 put(o, inside_index);
                 inside_index += 1;
+            }
             outside_index += 1;
+        }
+    }
     primitive receiver(in<u32> i, u32 outside_loops, u32 inside_loops) {
         u32 outside_index = 0;
         while (outside_index < outside_loops) {
             u32 inside_index = 0;
             sync while (inside_index < inside_loops) {
                 auto val = get(i);
                 while (val != inside_index) {} // infinite loop if incorrect value is received
                 inside_index += 1;
+            }
             outside_index += 1;
+        }
+    }
     composite constructor() {
         channel o_orom -> i_orom;
         channel o_mrom -> i_mrom;
         channel o_ormm -> i_ormm;
         channel o_mrmm -> i_mrmm;
         // one round, one message per round
         new sender(o_orom, 1, 1);
         new receiver(i_orom, 1, 1);
         // multiple rounds, one message per round
         new sender(o_mrom, 5, 1);
         new receiver(i_mrom, 5, 1);
         // one round, multiple messages per round
         new sender(o_ormm, 1, 5);
         new receiver(i_ormm, 1, 5);
         // multiple rounds, multiple messages per round
         new sender(o_mrmm, 5, 5);
         new receiver(i_mrmm, 5, 5);
     }").expect("compilation");
     let rt = Runtime::new(3, true, pd);
+    let rt = Runtime::new(3, true, pd).unwrap();
     create_component(&rt, "", "constructor", no_args());
+}
 #[test]
 fn test_intermediate_messenger() {
     let pd = ProtocolDescription::parse(b"
     primitive receiver<T>(in<T> rx, u32 num) {
         auto index = 0;
         while (index < num) {
             sync { auto v = get(rx); }
             index += 1;
+        }
+    }
     primitive middleman<T>(in<T> rx, out<T> tx, u32 num) {
         auto index = 0;
         while (index < num) {
             sync { put(tx, get(rx)); }
             index += 1;
+        }
+    }
     primitive sender<T>(out<T> tx, u32 num) {
         auto index = 0;
         while (index < num) {
             sync put(tx, 1337);
             index += 1;
+        }
+    }
     composite constructor_template<T>() {
         auto num = 0;
         channel<T> tx_a -> rx_a;
         channel tx_b -> rx_b;
         new sender(tx_a, 3);
         new middleman(rx_a, tx_b, 3);
         new receiver(rx_b, 3);
+    }
     composite constructor() {
         new constructor_template<u16>();
         new constructor_template<u32>();
         new constructor_template<u64>();
         new constructor_template<s16>();
         new constructor_template<s32>();
         new constructor_template<s64>();
+    }
     ").expect("compilation");
     let rt = Runtime::new(3, true, pd);
+    let rt = Runtime::new(3, true, pd).unwrap();
     create_component(&rt, "", "constructor", no_args());
+}
 #[test]
 fn test_simple_select() {
     let pd = ProtocolDescription::parse(b"
     func infinite_assert<T>(T val, T expected) -> () {
         while (val != expected) { print(\"nope!\"); }
         return ();
+    }
     primitive receiver(in<u32> in_a, in<u32> in_b, u32 num_sends) {
         auto num_from_a = 0;
         auto num_from_b = 0;
         while (num_from_a + num_from_b < 2 * num_sends) {
             sync select {
                 auto v = get(in_a) -> {
                     print(\"got something from A\");
                     auto _ = infinite_assert(v, num_from_a);
                     num_from_a += 1;
+                }
                 auto v = get(in_b) -> {
                     print(\"got something from B\");
                     auto _ = infinite_assert(v, num_from_b);
                     num_from_b += 1;
+                }
+            }
+        }
+    }
     primitive sender(out<u32> tx, u32 num_sends) {
         auto index = 0;
         while (index < num_sends) {
             sync {
                 put(tx, index);
                 index += 1;
+            }
+        }
+    }
     composite constructor() {
-        auto num_sends = 15;
+        auto num_sends = 1;
         channel tx_a -> rx_a;
         channel tx_b -> rx_b;
         new sender(tx_a, num_sends);
         new receiver(rx_a, rx_b, num_sends);
         new sender(tx_b, num_sends);
+    }
     ").expect("compilation");
-    let rt = Runtime::new(3, false, pd);
+    let rt = Runtime::new(3, true, pd).unwrap();
     create_component(&rt, "", "constructor", no_args());
+}
 #[test]
 fn test_unguarded_select() {
     let pd = ProtocolDescription::parse(b"
     primitive constructor_outside_select() {
         u32 index = 0;
         while (index < 5) {
             sync select { auto v = () -> print(\"hello\"); }
             index += 1;
+        }
+    }
     primitive constructor_inside_select() {
         u32 index = 0;
         while (index < 5) {
             sync select { auto v = () -> index += 1; }
+        }
+    }
     ").expect("compilation");
     let rt = Runtime::new(3, false, pd);
+    let rt = Runtime::new(3, false, pd).unwrap();
     create_component(&rt, "", "constructor_outside_select", no_args());
     create_component(&rt, "", "constructor_inside_select", no_args());
+}
 #[test]
 fn test_empty_select() {
     let pd = ProtocolDescription::parse(b"
     primitive constructor() {
         u32 index = 0;
         while (index < 5) {
             sync select {}
             index += 1;
+        }
+    }
     ").expect("compilation");
     let rt = Runtime::new(3, false, pd);
+    let rt = Runtime::new(3, false, pd).unwrap();
     create_component(&rt, "", "constructor", no_args());
+}
 #[test]
 fn test_random_u32_temporary_thingo() {
     let pd = ProtocolDescription::parse(b"
     import std.random::random_u32;
     primitive random_taker(in<u32> generator, u32 num_values) {
         auto i = 0;
         while (i < num_values) {
             sync {
                 auto a = get(generator);
+            }
             i += 1;
+        }
+    }
     composite constructor() {
         channel tx -> rx;
         auto num_values = 25;
         new random_u32(tx, 1, 100, num_values);
         new random_taker(rx, num_values);
+    }
     ").expect("compilation");
     let rt = Runtime::new(1, true, pd);
+    let rt = Runtime::new(1, true, pd).unwrap();
     create_component(&rt, "", "constructor", no_args());
+}
@@ \ No newline at end of file @@

0 comments (0 inline, 0 general)