mbrubeck

// XML parsing adventure

#![license = "MIT"]
#![feature(phase)]


// extern crate simhash;

#[phase(plugin)]
extern crate peg_syntax_ext;

mbrubeck

#[macro_use]
extern crate nickel;
extern crate yaml_rust;

use nickel::{ Nickel, HttpRouter };
use yaml_rust::{ Yaml, YamlEmitter };

mod yaml_handler;

fn get_yaml() -> String {

mbrubeck

use std::cmp::Ordering;
use std::fmt::Debug;

extern crate scoped_pool;
use scoped_pool::{Pool, Scope};


/// An insertion sort for small slices
#[inline]
fn insertion_sort<T>(arr: &mut [T], left: usize, right: usize) where T: Ord {

mbrubeck

use std::io::stdin;
use std::io::Read;
use std::rc::Rc;
use std::cell::RefCell;
use std::cmp::max;
#[derive(Debug, Copy, Clone)]
struct Position(u16, u16);
impl Position {
    fn adjacent(&self, other: &Position) -> bool { 
        max((self.0 as i16 - other.0 as i16).abs(), (self.1 as i16 - other.1 as i16).abs()) <= 1 

mbrubeck

impl<T: Transport> BufferedTransport<T> {

    fn get_bytes(&mut self) -> io::Result<&[u8]> {
        if self.rpos == self.rbuf.len() {
            self.rpos = 0;
            self.rcap = try!(self.underlying.read(&mut self.rbuf));
        }

        Ok(&self.rbuf[self.rpos..self.rcap])
    }

mbrubeck

bench: libauthz.so
	python2 main.py

libauthz.so: rusty_authz.rs Makefile
	rustc -C opt-level=3 -C lto rusty_authz.rs --crate-type cdylib -o libauthz.so

.PHONY: bench

mbrubeck

#![feature(libc)]
#![feature(test)]
extern crate libc;
extern crate test;

use std::slice;
use std::ffi::CStr;
use std::str;
use libc::{size_t, c_char};
use std::collections::HashSet;

mbrubeck

#![feature(libc)]
#![feature(test)]
extern crate libc;
extern crate test;
extern crate seahash;

use std::slice;
use std::ffi::CStr;
use std::panic;
use std::str;

mbrubeck

#![feature(const_fn)]

// rust self-tracing benchmark using DebugCtl.BTF

extern crate winapi;
extern crate kernel32;
extern crate libc;

use std::time::Instant;

mbrubeck

inside: TreeIterator { current: Tree { nodes: [None, None] }, depth: 0 }
Got out Tree { nodes: [None, None] }
After first inc(0) Tree { nodes: [None, None] }
After second inc(1) Tree { nodes: [Some(Tree { nodes: [None, None] }), None] }
next tree: Some(Tree { nodes: [None, None] })
inside: TreeIterator { current: Tree { nodes: [Some(Tree { nodes: [None, None] }), None] }, depth: 1 }
Got out Tree { nodes: [Some(Tree { nodes: [None, None] }), Some(Tree { nodes: [None, None] })] }
After first inc(1) Tree { nodes: [Some(Tree { nodes: [None, None] }), Some(Tree { nodes: [None, None] })] }
next tree: Some(Tree { nodes: [Some(Tree { nodes: [None, None] }), Some(Tree { nodes: [None, None] })] })
inside: TreeIterator { current: Tree { nodes: [Some(Tree { nodes: [None, None] }), Some(Tree { nodes: [None, None] })] }, depth: 1 }