FoldExpr { op: InfixOp, args: Vec<Expr>

• Prevents panic when kind is not "sum" or "product"
• Allows extension to fold more operations

import a
b = a and (a and a)

produces b=a and a and a, but should produce b=a and(a and a)

Use associativity instead of commutativity for bracket choices in formatter

Use failure crate

• Remove extraneous brackets using information about precedence
• Limit lines to 70 chars

• Focus on automatic parallel computation
• Distribute workload over n chips
• Leave comments on "wait" lines

• Iteratively fold and propagate constants
• Implement methods for emulating YOLOL ops

• Optimization: maintain "as-is" property
• Correctness: specify desired result in convention variable x

Source:

define foo(a) = sum(a);
let n = foo(0);
export n;

Error:

thread 'main' panicked at 'undefined variable: a', src/bin/yolkc.rs:30:68

• Ensure that optimize is idempotent
• Create tests/idempotence.rs

import a
let b = 1 + (2 + a)
export b

produces b=1+2+a, but should produce b=3+a.

Can add match case to optimizer. Need to handle both (2+a) and (a+2), as well as all other commutative operations.

• Use serde

• Similar to Yovec: yolk -i source.yolk -o out.yolol

• In examples dir
• Ignore in Cargo.toml

• Add examples and panics for parse, transpile, and optimize

• Prevent common panics

Text -> YolkNode

• Show example first
• Offer bullet point differences from Yolol

YOLOL -> Yolol

In src/lib.rs

pub use parser::parse;
pub use transpiler::transpile;
pub us optimizer::optimize;

• Build DAG to track living variables

• Only allow between statements and within expressions

e.g. Disallow importa

• Similar to Yovec

• ParseError, TranspileError, etc.
• Always return base Error
• Implement From methods

After the newline change, semicolons are no longer required

• Move YololNode::format_as_program
• Remove to_string impls in ast.rs

• Separate passes into different files
• Reduce clones

yolol_ssa?

• Too confusing, offers little better
• Already included in Martin's optimizer
• Focus more on expression reduction

• Remove limitations from grammar
• Handle errors generated by YololNumber::from_str

Propagate source statements and expressions through into errors

Same format as YOLOL: // comment goes here

• Index: get single elem

• Slice: get array of elems

• index_expr = { expr ~ "[" ~ NUM ~ "]" }

• slice_expr = { expr ~ "[" ~ NUM ~ ":" ~ NUM ~ "]" }

YolkNode -> YololNode

• --debug
• Print IR for parsed Yolk, transpiled Yolol, optimized Yolol

Replace TODOs

Return YolkError::BadParse instead

https://rustwasm.github.io/docs/book/

Must use yolol_number::prelude::*;

import a
let b = 1 - (2-a)
export b

produces b=1-2-a, but should produce b=1-2+a, or at least b=1-(2-a)

See TODOs in ast.rs

• Implement to_string for YololStmt, YololExpr
• to_string internally calls format_stmt, etc.

Waiting for fix in yolol_number

• YololNode -> YololNode
• Use Yoloxide to ensure that environment is consistent

TL;DR

Refocus Yolk on pipelined, parallel computation.

Abstract

Yolk currently focuses on single-chip numerical computing. This proposal would allow Yolk to seamlessly spread its Yolol output over n chips, making use of m data fields as registers. A scheduler would be implemented to manage statement execution.

Scheduling Algorithm

1. Build a DAG of variable dependencies. Yolk's SSA form ensures that the dependency graph is acyclic.

2. Linearize the DAG into stages. Statements within the same stage may be executed in any order.

3. Assign statements to chips. All statements in stage n must execute before any statements in stage n+1. The assignment algorithm will minimize the following criteria, in order:

   1. Maximum number of lines on a single chip

   2. Number of chips used

   3. Number of register saves and loads

4. Add register saves and loads to share values between stages. Register positions have already been marked by the previous step.

5. Map stages to physical lines on chips. Some stages may take more than one physical line. Insert // Sync comments on empty lines.

• Use references and lifetimes