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

Changeset - 97b87404ffa5

Parent rev.

Child rev.

[Not reviewed]

0 5 0

mh - 4 years ago 2021-12-16 10:34:10
contact@maxhenger.nl

WIP on performance fixes

5 files changed with 81 insertions and 50 deletions:

src/collections/scoped_buffer.rs

src/protocol/parser/pass_definitions.rs

src/protocol/parser/pass_typing.rs

src/protocol/parser/pass_validation_linking.rs

src/protocol/parser/visitor.rs

0 comments (0 inline, 0 general)

src/collections/scoped_buffer.rs

➞

Show inline comments

@@ @@ -23,13 +23,13 @@ pub(crate) struct ScopedSection<T: Sized> { @@
     inner: *mut Vec<T>,
     start_size: u32,
     #[cfg(debug_assertions)] cur_size: u32,
+}
 impl<T: Sized> ScopedBuffer<T> {
-    pub(crate) fn new_reserved(capacity: usize) -> Self {
+    pub(crate) fn with_capacity(capacity: usize) -> Self {
         Self { inner: Vec::with_capacity(capacity) }
+    }
     pub(crate) fn start_section(&mut self) -> ScopedSection<T> {
         let start_size = self.inner.len() as u32;
         ScopedSection {
@@ @@ -103,12 +103,22 @@ impl<T: Sized> ScopedSection<T> { @@
+        }
         let section = Vec::from_iter(vec.drain(self.start_size as usize..));
         section
+    }
+}
 impl<T: Copy> ScopedSection<T> {
     pub(crate) fn iter_copied(&self) -> ScopedIter<T> {
         return ScopedIter{
             inner: self.inner,
             cur_index: self.start_size,
             last_index: unsafe{ (*self.inner).len() as u32 },
+        }
+    }
+}
 impl<T: Sized> std::ops::Index<usize> for ScopedSection<T> {
     type Output = T;
     fn index(&self, idx: usize) -> &Self::Output {
         let vec = unsafe{&*self.inner};
         return &vec[self.start_size as usize + idx]
@@ @@ -120,6 +130,27 @@ impl<T: Sized> Drop for ScopedSection<T> { @@
     fn drop(&mut self) {
         let vec = unsafe{&mut *self.inner};
         #[cfg(debug_assertions)] debug_assert_eq!(vec.len(), self.cur_size as usize);
         vec.truncate(self.start_size as usize);
+    }
+}
 pub(crate) struct ScopedIter<T: Copy> {
     inner: *mut Vec<T>,
     cur_index: u32,
     last_index: u32,
+}
 impl<T: Copy> Iterator for ScopedIter<T> {
     type Item = T;
     fn next(&mut self) -> Option<Self::Item> {
         if self.cur_index >= self.last_index {
             return None;
+        }
         let vec = unsafe{ &*self.inner };
         let index = self.cur_index as usize;
         self.cur_index += 1;
         return Some(vec[index]);
+    }
+}
@@ \ No newline at end of file @@

src/protocol/parser/pass_definitions.rs

➞

Show inline comments

@@ @@ -28,19 +28,19 @@ pub(crate) struct PassDefinitions { @@
 impl PassDefinitions {
     pub(crate) fn new() -> Self {
         Self{
             cur_definition: DefinitionId::new_invalid(),
             type_parser: ParserTypeParser::new(),
             buffer: String::with_capacity(128),
             struct_fields: ScopedBuffer::new_reserved(128),
             enum_variants: ScopedBuffer::new_reserved(128),
             union_variants: ScopedBuffer::new_reserved(128),
             variables: ScopedBuffer::new_reserved(128),
             expressions: ScopedBuffer::new_reserved(128),
             statements: ScopedBuffer::new_reserved(128),
             parser_types: ScopedBuffer::new_reserved(128),
             struct_fields: ScopedBuffer::with_capacity(128),
             enum_variants: ScopedBuffer::with_capacity(128),
             union_variants: ScopedBuffer::with_capacity(128),
             variables: ScopedBuffer::with_capacity(128),
             expressions: ScopedBuffer::with_capacity(128),
             statements: ScopedBuffer::with_capacity(128),
             parser_types: ScopedBuffer::with_capacity(128),
+        }
+    }
     pub(crate) fn parse(&mut self, modules: &mut [Module], module_idx: usize, ctx: &mut PassCtx) -> Result<(), ParseError> {
         let module = &modules[module_idx];
         let module_range = &module.tokens.ranges[0];

src/protocol/parser/pass_typing.rs

➞

Show inline comments

@@ @@ -46,21 +46,20 @@ macro_rules! debug_log { @@
         enabled_debug_print!(false, "types", $format, $($args),*);
     };
+}
 use std::collections::{HashMap, HashSet};
 use crate::collections::DequeSet;
+use crate::collections::{ScopedBuffer, DequeSet};
 use crate::protocol::ast::*;
 use crate::protocol::input_source::ParseError;
 use crate::protocol::parser::ModuleCompilationPhase;
 use crate::protocol::parser::type_table::*;
 use crate::protocol::parser::token_parsing::*;
 use super::visitor::{
     STMT_BUFFER_INIT_CAPACITY,
     EXPR_BUFFER_INIT_CAPACITY,
     BUFFER_INIT_CAPACITY,
     Ctx,
     Visitor,
     VisitorResult
 };
 const VOID_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::Void ];
@@ @@ -855,17 +854,16 @@ impl Default for InferenceExpression { @@
 /// that all expressions have the appropriate types.
 pub(crate) struct PassTyping {
     // Current definition we're typechecking.
     reserved_idx: i32,
     definition_type: DefinitionType,
     poly_vars: Vec<ConcreteType>,
     // Buffers for iteration over substatements and subexpressions
     stmt_buffer: Vec<StatementId>,
     expr_buffer: Vec<ExpressionId>,
     var_buffer: ScopedBuffer<VariableId>,
     expr_buffer: ScopedBuffer<ExpressionId>,
     stmt_buffer: ScopedBuffer<StatementId>,
     // Mapping from parser type to inferred type. We attempt to continue to
     // specify these types until we're stuck or we've fully determined the type.
     var_types: HashMap<VariableId, VarData>,            // types of variables
     expr_types: Vec<InferenceExpression>,                     // will be transferred to type table at end
     extra_data: Vec<ExtraData>,       // data for polymorph inference
     // Keeping track of which expressions need to be reinferred because the
@@ @@ -919,14 +917,15 @@ impl VarData { @@
 impl PassTyping {
     pub(crate) fn new() -> Self {
         PassTyping {
             reserved_idx: -1,
             definition_type: DefinitionType::Function(FunctionDefinitionId::new_invalid()),
             poly_vars: Vec::new(),
             stmt_buffer: Vec::with_capacity(STMT_BUFFER_INIT_CAPACITY),
             expr_buffer: Vec::with_capacity(EXPR_BUFFER_INIT_CAPACITY),
             var_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAPACITY),
             expr_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAPACITY),
             stmt_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAPACITY),
             var_types: HashMap::new(),
             expr_types: Vec::new(),
             extra_data: Vec::new(),
             expr_queued: DequeSet::new(),
+        }
+    }
@@ @@ -994,14 +993,12 @@ impl PassTyping { @@
+    }
     fn reset(&mut self) {
         self.reserved_idx = -1;
         self.definition_type = DefinitionType::Function(FunctionDefinitionId::new_invalid());
         self.poly_vars.clear();
         self.stmt_buffer.clear();
         self.expr_buffer.clear();
         self.var_types.clear();
         self.expr_types.clear();
         self.extra_data.clear();
         self.expr_queued.clear();
+    }
+}
@@ @@ -1021,18 +1018,20 @@ impl Visitor for PassTyping { @@
         // Reserve data for expression types
         debug_assert!(self.expr_types.is_empty());
         self.expr_types.resize(comp_def.num_expressions_in_body as usize, Default::default());
         // Visit parameters
         for param_id in comp_def.parameters.clone() {
         let section = self.var_buffer.start_section_initialized(comp_def.parameters.as_slice());
         for param_id in section.iter_copied() {
             let param = &ctx.heap[param_id];
             let var_type = self.determine_inference_type_from_parser_type_elements(&param.parser_type.elements, true);
             debug_assert!(var_type.is_done, "expected component arguments to be concrete types");
             self.var_types.insert(param_id, VarData::new_local(var_type));
+        }
         section.forget();
         // Visit the body and all of its expressions
         let body_stmt_id = ctx.heap[id].body;
         self.visit_block_stmt(ctx, body_stmt_id)
+    }
@@ @@ -1059,33 +1058,37 @@ impl Visitor for PassTyping { @@
         // Reserve data for expression types
         debug_assert!(self.expr_types.is_empty());
         self.expr_types.resize(func_def.num_expressions_in_body as usize, Default::default());
         // Visit parameters
         for param_id in func_def.parameters.clone() {
         let section = self.var_buffer.start_section_initialized(func_def.parameters.as_slice());
         for param_id in section.iter_copied() {
             let param = &ctx.heap[param_id];
             let var_type = self.determine_inference_type_from_parser_type_elements(&param.parser_type.elements, true);
             debug_assert!(var_type.is_done, "expected function arguments to be concrete types");
             self.var_types.insert(param_id, VarData::new_local(var_type));
+        }
         section.forget();
         // Visit all of the expressions within the body
         let body_stmt_id = ctx.heap[id].body;
         self.visit_block_stmt(ctx, body_stmt_id)
+    }
     // Statements
     fn visit_block_stmt(&mut self, ctx: &mut Ctx, id: BlockStatementId) -> VisitorResult {
         // Transfer statements for traversal
         let block = &ctx.heap[id];
         for stmt_id in block.statements.clone() {
         let section = self.stmt_buffer.start_section_initialized(block.statements.as_slice());
         for stmt_id in section.iter_copied() {
             self.visit_stmt(ctx, stmt_id)?;
+        }
         section.forget();
         Ok(())
+    }
     fn visit_local_memory_stmt(&mut self, ctx: &mut Ctx, id: MemoryStatementId) -> VisitorResult {
         let memory_stmt = &ctx.heap[id];
@@ @@ -1309,47 +1312,46 @@ impl Visitor for PassTyping { @@
         match &literal_expr.value {
             Literal::Null | Literal::False | Literal::True |
             Literal::Integer(_) | Literal::Character(_) | Literal::String(_) => {
                 // No subexpressions
             },
             Literal::Struct(literal) => {
                 // TODO: @performance
                 let expr_ids: Vec<_> = literal.fields
                     .iter()
                     .map(|f| f.value)
                     .collect();
                 let mut expr_ids = self.expr_buffer.start_section();
                 for field in &literal.fields {
                     expr_ids.push(field.value);
+                }
                 self.insert_initial_struct_polymorph_data(ctx, id);
                 for expr_id in expr_ids {
+                for expr_id in expr_ids.iter_copied() {
                     self.visit_expr(ctx, expr_id)?;
+                }
                 expr_ids.forget();
             },
             Literal::Enum(_) => {
                 // Enumerations do not carry any subexpressions, but may still
                 // have a user-defined polymorphic marker variable. For this
                 // reason we may still have to apply inference to this
                 // polymorphic variable
                 self.insert_initial_enum_polymorph_data(ctx, id);
             },
             Literal::Union(literal) => {
                 // May carry subexpressions and polymorphic arguments
                 // TODO: @performance
                 let expr_ids = literal.values.clone();
                 let expr_ids = self.expr_buffer.start_section_initialized(literal.values.as_slice());
                 self.insert_initial_union_polymorph_data(ctx, id);
                 for expr_id in expr_ids {
+                for expr_id in expr_ids.iter_copied() {
                     self.visit_expr(ctx, expr_id)?;
+                }
                 expr_ids.forget();
             },
             Literal::Array(expressions) | Literal::Tuple(expressions) => {
                 // TODO: @performance
                 let expr_ids = expressions.clone();
                 for expr_id in expr_ids {
                 let expr_ids = self.expr_buffer.start_section_initialized(expressions.as_slice());
                 for expr_id in expr_ids.iter_copied() {
                     self.visit_expr(ctx, expr_id)?;
+                }
                 expr_ids.forget();
+            }
+        }
         self.progress_literal_expr(ctx, id)
+    }
@@ @@ -1374,15 +1376,17 @@ impl Visitor for PassTyping { @@
         // up not being a polymorphic one, then we will select the default
         // expression types in the type table
         let call_expr = &ctx.heap[id];
         self.expr_types[call_expr.unique_id_in_definition as usize].field_or_monomorph_idx = 0;
         // Visit all arguments
         for arg_expr_id in call_expr.arguments.clone() { // TODO: @Performance
         let expr_ids = self.expr_buffer.start_section_initialized(call_expr.arguments.as_slice());
         for arg_expr_id in expr_ids.iter_copied() {
             self.visit_expr(ctx, arg_expr_id)?;
+        }
         expr_ids.forget();
         self.progress_call_expr(ctx, id)
+    }
     fn visit_variable_expr(&mut self, ctx: &mut Ctx, id: VariableExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
@@ @@ -1619,13 +1623,13 @@ impl PassTyping { @@
+        }
         Ok(())
+    }
     fn progress_expr(&mut self, ctx: &mut Ctx, idx: i32) -> Result<(), ParseError> {
-        let id = self.expr_types[idx as usize].expr_id; // TODO: @Temp
         let id = self.expr_types[idx as usize].expr_id;
         match &ctx.heap[id] {
             Expression::Assignment(expr) => {
                 let id = expr.this;
                 self.progress_assignment_expr(ctx, id)
             },
             Expression::Binding(expr) => {
@@ @@ -2149,13 +2153,13 @@ impl PassTyping { @@
+                }
                 // If here then field index is known, and the referenced struct type
                 // information is inserted into `extra_data`. Check to see if we can
                 // do some mutual inference.
                 let poly_data = &mut self.extra_data[extra_idx as usize];
                 let mut poly_progress = HashSet::new();
+                let mut poly_progress = HashSet::new(); // TODO: @Performance
                 // Apply to struct's type
                 let signature_type: *mut _ = &mut poly_data.embedded[0];
                 let subject_type: *mut _ = &mut self.expr_types[subject_expr_idx as usize].expr_type;
                 let (_, progress_subject) = Self::apply_equal2_signature_constraint(
@@ @@ -2515,12 +2519,13 @@ impl PassTyping { @@
                     extra, &poly_progress, signature_type, expr_type
                 );
                 progress_expr
             },
             Literal::Array(data) => {
                 // TODO: Continue here with performance improvements by reducing allocations
                 let expr_elements = data.clone(); // TODO: @performance
                 debug_log!("Array expr ({} elements): {}", expr_elements.len(), upcast_id.index);
                 debug_log!(" * Before:");
                 debug_log!("   - Expr type: {}", self.debug_get_display_name(ctx, upcast_id));
                 // All elements should have an equal type

src/protocol/parser/pass_validation_linking.rs

➞

Show inline comments

@@ @@ -39,14 +39,13 @@ use crate::collections::{ScopedBuffer}; @@
 use crate::protocol::ast::*;
 use crate::protocol::input_source::*;
 use crate::protocol::parser::symbol_table::*;
 use crate::protocol::parser::type_table::*;
 use super::visitor::{
     STMT_BUFFER_INIT_CAPACITY,
     EXPR_BUFFER_INIT_CAPACITY,
     BUFFER_INIT_CAPACITY,
     Ctx,
     Visitor,
     VisitorResult
 };
 use crate::protocol::parser::ModuleCompilationPhase;
@@ @@ -123,16 +122,16 @@ impl PassValidationLinking { @@
             prev_stmt: StatementId::new_invalid(),
             expr_parent: ExpressionParent::None,
             def_type: DefinitionType::Function(FunctionDefinitionId::new_invalid()),
             must_be_assignable: None,
             relative_pos_in_block: 0,
             next_expr_index: 0,
             variable_buffer: ScopedBuffer::new_reserved(128),
             definition_buffer: ScopedBuffer::new_reserved(128),
             statement_buffer: ScopedBuffer::new_reserved(STMT_BUFFER_INIT_CAPACITY),
             expression_buffer: ScopedBuffer::new_reserved(EXPR_BUFFER_INIT_CAPACITY),
             variable_buffer: ScopedBuffer::with_capacity(128),
             definition_buffer: ScopedBuffer::with_capacity(128),
             statement_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAPACITY),
             expression_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAPACITY),
+        }
+    }
     fn reset_state(&mut self) {
         self.in_sync = SynchronousStatementId::new_invalid();
         self.in_while = WhileStatementId::new_invalid();

src/protocol/parser/visitor.rs

➞

Show inline comments

@@ @@ -3,18 +3,14 @@ use crate::protocol::input_source::ParseError; @@
 use crate::protocol::parser::{type_table::*, Module};
 use crate::protocol::symbol_table::{SymbolTable};
 type Unit = ();
 pub(crate) type VisitorResult = Result<Unit, ParseError>;
 /// Globally configured vector capacity for statement buffers in visitor
 /// implementations
 pub(crate) const STMT_BUFFER_INIT_CAPACITY: usize = 256;
 /// Globally configured vector capacity for expression buffers in visitor
 /// implementations
 pub(crate) const EXPR_BUFFER_INIT_CAPACITY: usize = 256;
 /// Globally configured vector capacity for buffers in visitor implementations
 pub(crate) const BUFFER_INIT_CAPACITY: usize = 256;
 /// General context structure that is used while traversing the AST.
 pub(crate) struct Ctx<'p> {
     pub heap: &'p mut Heap,
     pub modules: &'p mut [Module],
     pub module_idx: usize, // currently considered module

0 comments (0 inline, 0 general)