add rust

bench_results.md

@@ -1,15 +1,16 @@
 Processor: Intel i5-5200U (2.2GHz/2.7GHz turbo)
 
-# bf.py, very naive
+# Python
+## bf.py, very naive
 
-## bench.b
+### bench.b
 ```
 real    14m8.526s
 user    14m8.542s
 sys     0m0.010s
 ```
 
-## mandel.b
+### mandel.b
 ```
 real    209m11.773s
 user    209m11.755s
@@ -17,16 +18,16 @@ sys     0m0.374s
 ```
 
 
-# bf2.py, non-slot
+## bf2.py, non-slot
 
-## bench.b
+### bench.b
 ```
 real    10m21.137s
 user    10m21.162s
 sys     0m0.010s
 ```
 
-## mandel.b
+### mandel.b
 ```
 real    103m31.439s
 user    103m30.069s
@@ -34,16 +35,16 @@ sys     0m0.813s
 ```
 
 
-# bf2.py, slotted
+## bf2.py, slotted
 
-## bench.b
+### bench.b
 ```
 real    9m10.573s
 user    9m10.418s
 sys     0m0.127s
 ```
 
-## mandel.b
+### mandel.b
 ```
 real    93m11.907s
 user    93m10.734s
@@ -51,18 +52,35 @@ sys     0m0.673s
 ```
 
 
-# pypy3 bf2.py, slotted
+## pypy3 bf2.py, slotted
 
-## bench.b
+### bench.b
 ```
 real    0m29.793s
 user    0m29.759s
 sys     0m0.033s
 ```
 
-## mandel.b
+### mandel.b
 ```
 real    2m36.409s
 user    2m36.338s
 sys     0m0.063s
 ```
+
+# Rust
+## rustc -C opt-level=3 bf.rs
+
+### bench.b
+```
+real    0m2.536s
+user    0m2.536s
+sys     0m0.001s
+```
+
+### mandel.b
+```
+real    0m30.233s
+user    0m30.229s
+sys     0m0.003s
+```

python/bf.py

@@ -42,7 +42,7 @@ class UByte(Mixin, ctypes.c_ubyte):
 
 Int = lambda x: x
 
-TYPE = Byte
+TYPE = Int
 
 
 class Machine:

rust/bf.rs

@@ -0,0 +1,133 @@
+use std::env;
+use std::io;
+use std::io::Read;
+use std::fs::File;
+
+struct Tape {
+    pointer: usize,
+    tape: [u8; 30000],
+}
+
+impl Tape {
+    fn get_data(&mut self) -> u8 {
+        self.tape[self.pointer]
+    }
+
+    fn increment_pointer(&mut self) {
+        self.pointer += 1;
+    }
+
+    fn decrement_pointer(&mut self) {
+        self.pointer -= 1;
+    }
+
+    fn increment_cell(&mut self) {
+        self.tape[self.pointer] += 1;
+    }
+
+    fn decrement_cell(&mut self) {
+        self.tape[self.pointer] -= 1;
+    }
+
+    fn print_cell(&mut self) {
+        print!("{}", self.get_data() as u8 as char);
+    }
+
+    fn input_to_cell(&mut self) {
+        self.tape[self.pointer] = io::stdin()
+            .bytes()
+            .next()
+            .and_then(|result| result.ok())
+            .map(|byte| byte as u8)
+            .expect("Failed to read byte");
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+enum Token {
+    IncrementPointer,
+    DecrementPointer,
+    IncrementCell,
+    DecrementCell,
+    PrintCell,
+    Input,
+    LoopStart,
+    LoopEnd,
+}
+
+#[derive(Clone, Debug)]
+enum Command {
+    Do(Token),
+    Loop(Vec<Command>),
+}
+
+fn tokenize(data: Vec<u8>) -> Vec<Token> {
+    let mut tokens = Vec::new();
+
+    for u8_char in data {
+        tokens.push(match u8_char as char {
+            '>' => Token::IncrementPointer,
+            '<' => Token::DecrementPointer,
+            '+' => Token::IncrementCell,
+            '-' => Token::DecrementCell,
+            '.' => Token::PrintCell,
+            ',' => Token::Input,
+            '[' => Token::LoopStart,
+            ']' => Token::LoopEnd,
+            _  => continue,
+        })
+    }
+    tokens
+}
+
+fn parse(start: usize, tokens: &Vec<Token>) -> (Vec<Command>, usize) {
+    let mut program = Vec::new();
+    let mut index = start;
+    while index < tokens.len() {
+        match tokens[index] {
+            Token::LoopStart => {
+                let res = parse(index+1, &tokens);
+                program.push(Command::Loop(res.0));
+                index = res.1;
+            }
+            Token::LoopEnd => { return (program, index); }
+            _ => program.push(Command::Do(tokens[index])),
+        }
+        index += 1;
+    }
+    (program, index)
+}
+
+fn run(program: &Vec<Command>, tape: &mut Tape) {
+    for command in program {
+        match *command {
+            Command::Do(Token::IncrementPointer) => tape.increment_pointer(),
+            Command::Do(Token::DecrementPointer) => tape.decrement_pointer(),
+            Command::Do(Token::IncrementCell) => tape.increment_cell(),
+            Command::Do(Token::DecrementCell) => tape.decrement_cell(),
+            Command::Do(Token::PrintCell) => tape.print_cell(),
+            Command::Do(Token::Input) => tape.input_to_cell(),
+            Command::Loop(ref vec) => {
+                while tape.get_data() != 0 {
+                    run(vec, tape);
+                }
+            },
+            _ => continue,
+        }
+    }
+}
+
+fn read_file(name: String) -> Vec<u8> {
+    let mut f = File::open(name).expect("Couldn't open file");
+    let mut contents = Vec::new();
+    f.read_to_end(&mut contents).expect("Couldn't read file");
+    contents
+}
+
+fn main() {
+    let f = read_file(env::args().nth(1).expect("Need a file name"));
+    let tokens = tokenize(f);
+    let program = parse(0, &tokens).0;
+    let mut tape = Tape { pointer: 0, tape: [0; 30000] };
+    run(&program, &mut tape);
+}