Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

made optimization actually pog #298

Open
wants to merge 6 commits into
base: RWRT²
Choose a base branch
from
Open

made optimization actually pog #298

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
ec95a9d
made optimization actually pog
SpeckyYT Jan 24, 2023
639d673
Merge branch 'RWRT²' into bytecode-optimization
SpeckyYT Jan 25, 2023
829ed75
fixed and disabled the optimizer entirely
SpeckyYT Jan 25, 2023
fb15ef9
Merge branch 'RWRT²' into bytecode-optimization
SpeckyYT Jan 26, 2023
a739010
Merge branch 'RWRT²' into bytecode-optimization
SpeckyYT Jan 28, 2023
7812963
Merge branch 'RWRT²' into bytecode-optimization
SpeckyYT Feb 2, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
8 changes: 4 additions & 4 deletions src/compiling/compiler.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -8,6 +8,7 @@ use slotmap::{new_key_type, SlotMap};

use super::bytecode::{Bytecode, BytecodeBuilder, FuncBuilder, Function};
use super::error::CompilerError;
// use super::optimize::optimize_function;
use crate::cli::FileSettings;
use crate::parsing::ast::{
ExprNode, Expression, ImportType, MacroCode, Spannable, Spanned, Statement, StmtNode,
Expand Down Expand Up @@ -277,10 +278,9 @@ impl<'a> Compiler<'a> {
.functions
.into_iter()
.map(|f| {
// let v = if true { // TODO: change this to a debug flag or #[no_bytecode_optimization] attribute
// optimize_function(&v)
// } else {
// v
// let f = match self.file_attrs.no_optimize_bytecode {
// false => optimize_function(&f),
// true => f,
// };

let opcodes = f
Expand Down
2 changes: 1 addition & 1 deletion src/compiling/mod.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,6 +1,6 @@
pub mod bytecode;
pub mod compiler;
pub mod error;
// pub mod optimize;
// pub mod optimize; // this will remain disabled until rwrt is at a good point

// https://youtu.be/85R6_7xJW3s
265 changes: 187 additions & 78 deletions src/compiling/optimize.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,3 +1,6 @@
// CURRENT PROBLEM:
// - reading variables in a sub-macro isn't possible if optimized

use ahash::{HashMap, HashMapExt};

use crate::vm::opcodes::Opcode;
Expand All @@ -22,42 +25,6 @@ fn remove_unused(func: &Function<usize>) -> Function<usize> {
let mut write = [false; 1024]; // I guess 1024 are enough atm
let mut read = [false; 1024]; // we may change these to hashmaps or something, idk

for op in &func.opcodes {
match *op {
Opcode::LoadBuiltins { dest } => write[dest] = true,
Opcode::LoadConst { dest, id: _ } => write[dest] = true,
Opcode::LoadEmpty { dest } => write[dest] = true,
Opcode::LoadNone { dest } => write[dest] = true,
Opcode::Add { left, right, dest } => {
read[left] = true;
read[right] = true;
write[dest] = true;
}
Opcode::Sub { left, right, dest } => {
read[left] = true;
read[right] = true;
write[dest] = true;
}
Opcode::Copy { from, to } => {
read[from] = true;
write[to] = true;
}
Opcode::Print { reg } => {
read[reg] = true;
}
Opcode::JumpIfFalse { src, to: _ } => read[src] = true,
Opcode::Jump { to: _ } => {}
Opcode::Lt { left, right, dest } => {
read[left] = true;
read[right] = true;
write[dest] = true;
}
_ => {
println!("OPTIMIZATION: UNIMPLEMENTED OPERATOR [{:?}]", op);
},
}
}

let mut registers: HashMap<usize, usize> = HashMap::new();
let mut next_register = 0;
let mut get_reg = |reg| {
Expand All @@ -71,49 +38,191 @@ fn remove_unused(func: &Function<usize>) -> Function<usize> {
actual_reg
}
};
let is_used = |reg| {
match (read[reg], write[reg]) {
(true, true) => true,
(true, false) => false, // unreachable!(),
(false, true) => false,
(false, false) => false,
}
};

for (input, output) in &func.capture_regs {
write[*output] = true;
}

macro_rules! opcode {
($( $bytecode:ident { $( $var:ident($typ:ident) )* } )*) => {
{
for op in &func.opcodes {
opcode!(
READ/WRITE
op
$(
$bytecode { $( $var($typ) )* }
)*
);
}

let is_used = |reg| {
match (read[reg], write[reg]) {
(true, true) => true,
(true, false) => true, // this could be false
(false, true) => false,
(false, false) => false,
}
};

func.opcodes
.iter()
.copied()
.map(|op|
opcode!(
UNUSED
op
is_used
$(
$bytecode { $( $var($typ) )* }
)*
)
)
.collect()
}
};

(READ/WRITE $op:ident $( $bytecode:ident { $( $var:ident($typ:ident) )* } )*) => {
match *$op {
$(
#[allow(unused_variables)]
Opcode::$bytecode { $( $var, )* } => {
$(
opcode!(#READ/WRITE $var $typ);
)*
},
)*
_ => opcode!(UNIMPLEMENTED $op),
}
};
(#READ/WRITE $var:ident read) => { read[$var] = true; };
(#READ/WRITE $var:ident write) => { write[$var] = true; };
(#READ/WRITE $var:ident constant) => {};
(#READ/WRITE $var:ident jump) => {};
(#READ/WRITE $var:ident ignore) => {};

(UNUSED $op:ident $is_used:ident $( $bytecode:ident { $( $var:ident($typ:ident) )* } )*) => {
match $op {
$(
Opcode::$bytecode { $( $var, )* } => [$(opcode!(#IS_USED $is_used $var($typ)),)*].iter().all(|v| *v == true).then(|| Opcode::$bytecode {
$(
$var: opcode!(#UNUSED $var($typ)),
)*
}),
)*
_ => {
opcode!(UNIMPLEMENTED $op);
Some($op)
},
}
};
(#UNUSED $var:ident(read)) => { get_reg($var) };
(#UNUSED $var:ident(write)) => { get_reg($var) };
(#UNUSED $var:ident(constant)) => { $var };
(#UNUSED $var:ident(jump)) => { $var };
(#UNUSED $var:ident(ignore)) => { $var };

(#IS_USED $is_used:ident $var:ident(write)) => { $is_used($var) };
(#IS_USED $is_used:ident $var:ident($_:ident)) => { true };

(UNIMPLEMENTED $op:ident) => {
println!("OPTIMIZATION: UNIMPLEMENTED OPERATOR [{:?}]", $op)
};
}

let opcodes: Vec<Option<Opcode<usize>>> = opcode!(
LoadConst { id(constant) dest(write) }

Copy { from(read) to(write) }
Print { reg(read) }

Call { base(ignore) args(ignore) dest(write) }

AllocArray { size(ignore) dest(write) }
AllocDict { size(ignore) dest(write) }

PushArrayElem { elem(read) dest(write) }
PushDictElem { elem(read) key(ignore) dest(write) }

CreateMacro { id(ignore) dest(write) }
PushMacroArg { name(read) dest(write) }
SetMacroArgDefault { src(read) dest(write) }
SetMacroArgPattern { src(read) dest(write) }

Add { left(read) right(read) dest(write) }
Sub { left(read) right(read) dest(write) }
Mult { left(read) right(read) dest(write) }
Div { left(read) right(read) dest(write) }
Mod { left(read) right(read) dest(write) }
Pow { left(read) right(read) dest(write) }
ShiftLeft { left(read) right(read) dest(write) }
ShiftRight { left(read) right(read) dest(write) }
BinOr { left(read) right(read) dest(write) }
BinAnd { left(read) right(read) dest(write) }

// TODO: this requires an operator to be both read and write, which isn't implemented yet
AddEq { left(write) right(read) }
SubEq { left(write) right(read) }
MultEq { left(write) right(read) }
DivEq { left(write) right(read) }
ModEq { left(write) right(read) }
PowEq { left(write) right(read) }
ShiftLeftEq { left(write) right(read) }
ShiftRightEq { left(write) right(read) }
BinOrEq { left(write) right(read) }
BinAndEq { left(write) right(read) }
BinNotEq { left(write) right(read) }

Not { src(read) dest(write) }
Negate { src(read) dest(write) }
BinNot { src(read) dest(write) }

Eq { left(read) right(read) dest(write) }
Neq { left(read) right(read) dest(write) }

Gt { left(read) right(read) dest(write) }
Lt { left(read) right(read) dest(write) }
Gte { left(read) right(read) dest(write) }
Lte { left(read) right(read) dest(write) }

Range { left(read) right(read) dest(write) }
In { left(read) right(read) dest(write) }
As { left(read) right(read) dest(write) }
Is { left(read) right(read) dest(write) }

And { left(read) right(read) dest(write) }
Or { left(read) right(read) dest(write) }

Jump { to(jump) }
JumpIfFalse { src(read) to(jump) }

Ret { src(read) }

WrapMaybe { src(read) dest(write) }
LoadNone { dest(write) }
LoadEmpty { dest(write) }

Index { from(read) dest(write) index(read) }
Member { from(read) dest(write) member(read) }
Associated { from(read) dest(write) name(read) }

// empty enum?
// YeetContext
EnterArrowStatement { skip_to(jump) }

LoadBuiltins { dest(write) }

Export { src(read) }
Import { src(ignore) dest(write) }
);


let opcodes = func.opcodes.iter().copied().map(|op| match op {
Opcode::LoadBuiltins { dest } =>
is_used(dest).then(|| Opcode::LoadBuiltins { dest: get_reg(dest) }),
Opcode::LoadConst { dest, id } =>
is_used(dest).then(|| Opcode::LoadConst { dest: get_reg(dest), id }),
Opcode::LoadEmpty { dest } =>
is_used(dest).then(|| Opcode::LoadEmpty { dest: get_reg(dest) }),
Opcode::LoadNone { dest } =>
is_used(dest).then(|| Opcode::LoadNone { dest: get_reg(dest) }),
Opcode::Add { left, right, dest } =>
is_used(dest).then(|| Opcode::Add { left: get_reg(left), right: get_reg(right), dest: get_reg(dest) }),
Opcode::Sub { left, right, dest } =>
is_used(dest).then(|| Opcode::Sub { left: get_reg(left), right: get_reg(right), dest: get_reg(dest) }),
Opcode::Lt { left, right, dest } =>
is_used(dest).then(|| Opcode::Lt { left: get_reg(left), right: get_reg(right), dest: get_reg(dest) }),
Opcode::Lte { left, right, dest } =>
is_used(dest).then(|| Opcode::Lte { left: get_reg(left), right: get_reg(right), dest: get_reg(dest) }),
Opcode::Gt { left, right, dest } =>
is_used(dest).then(|| Opcode::Gt { left: get_reg(left), right: get_reg(right), dest: get_reg(dest) }),
Opcode::Gte { left, right, dest } =>
is_used(dest).then(|| Opcode::Gte { left: get_reg(left), right: get_reg(right), dest: get_reg(dest) }),
Opcode::Copy { from, to } =>
is_used(to).then(|| Opcode::Copy { from: get_reg(from), to: get_reg(to) }),
Opcode::Print { reg } => Some(Opcode::Print { reg: get_reg(reg) }),
Opcode::JumpIfFalse { src, to } => Some(Opcode::JumpIfFalse { src: get_reg(src), to }),
Opcode::Jump { to } => Some(Opcode::Jump { to }),
_ => {
println!("OPTIMIZATION: UNIMPLEMENTED OPERATOR [{:?}]", op);
Some(op)
},
})
.collect::<Vec<_>>();

let mut output = Function { opcodes: vec![] };
let mut output = func.clone();
output.opcodes.clear();
output.regs_used = read.clone().iter().filter(|v| **v).count();

// fix captures
output.capture_regs = output.capture_regs.iter().map(|(input, output)| (get_reg(*input), *output)).collect();

// fix jumps
for (_i, op) in opcodes.iter().enumerate().filter_map(|(i, v)| v.map(|v| (i, v))) {
Expand Down