// #![feature(test)]
// #![feature(alloc)]
// #![feature(heap_api)]
// #[macro_use]
// extern crate adapton ;

// mod fib {
//     const INPUT_SIZE:u64 = 20;
//     const REPEAT_COUNT:u64 = 100;
    
//     #[cfg(test)]
//     mod rust {
//         use super::INPUT_SIZE;
//         use super::REPEAT_COUNT;
        
//         extern crate test;
//         use self::test::Bencher;
        
//         pub fn fib (x:u64) -> u64 { test::black_box (
//             match x {
//                 0 => 0,
//                 1 => 1,
//                 x => fib(x-1) + fib(x-2)
//             })
//         }
        
//         pub fn fib_repeat (x:u64, n:u64) -> u64 {
//             for _ in 1..(n-1) {
//                 test::black_box(fib(x));
//             }
//             test::black_box(fib(x))
//         }

//         #[test]
//         fn it_works() {
//             assert_eq!(5 as u64, fib(5));
//         }
        
//         #[bench]
//         fn bench_fib(b: &mut Bencher) {
//             b.iter(|| test::black_box(fib(INPUT_SIZE)));
//         }

//         #[bench]
//         fn bench_fib_repeat(b: &mut Bencher) {
//             b.iter(|| test::black_box(fib_repeat(INPUT_SIZE, REPEAT_COUNT)));
//         }
//     }

//     #[cfg(test)]
//     mod adapton {
//         mod fs {
//             extern crate test;
//             use self::test::Bencher;
            
//             extern crate alloc;
//             use std::rc::Rc;
//             use adapton::macros::* ;
//             use adapton::adapton_sigs::* ;
//             //use adapton::adapton_state::* ;
//             use adapton::naive::* ;
//             use super::super::INPUT_SIZE;
//             use super::super::REPEAT_COUNT;
            
//             pub fn fib<A:Adapton> (st:&mut A, x:u64 ) -> u64 {
//                 match x {
//                     0 => 0,
//                     1 => 1,
//                     x => { memo!(st, fib, x:x-1)
//                            +
//                            memo!(st, fib, x:x-2) }}
//             }
            
//             pub fn run_fib (x:u64) -> u64 {
//                 let mut st = &mut AdaptonFromScratch::new() ;
//                 memo!(st, fib, x:x )
//             }
            
//             pub fn run_fib_repeat (x:u64, n:u64) -> u64 {
//                 let mut st = &mut AdaptonFromScratch::new() ;
//                 for _ in 1..(n-1) {
//                     memo!(st, fib, x:x );
//                 }
//                 memo!(st, fib, x:x )
//             }

//             #[test]
//             fn it_works() {
//                 assert_eq!(5 as u64, run_fib(5));
//             }
            
//             #[bench]
//             fn bench_fib(b: &mut Bencher) {
//                 b.iter(|| test::black_box(run_fib(INPUT_SIZE)));
//             }
                        
//             //#[bench]
//             //fn bench_fib_repeat(b: &mut Bencher) {
//             //    b.iter(|| test::black_box(run_fib_repeat(INPUT_SIZE, REPEAT_COUNT)));
//             //}
            
//         }

//         mod engine {
//             extern crate test;
//             use self::test::Bencher;
            
//             extern crate alloc;
//             use std::rc::Rc;
//             use adapton::macros::* ;
//             use adapton::adapton_sigs::* ;
//             use adapton::engine::* ;
//             //use adapton::naive::* ;
//             use super::super::INPUT_SIZE;
//             use super::super::REPEAT_COUNT;
            
//             pub fn fib<A:Adapton> (st:&mut A, x:u64 ) -> u64 {
//                 match x {
//                     0 => 0,
//                     1 => 1,
//                     x => { memo!(st, fib, x:x-1)
//                            +
//                            memo!(st, fib, x:x-2) }}
//             }
                            
//             pub fn run_fib (x:u64) -> u64 {
//                 let mut st = &mut Engine::new() ;
//                 memo!(st, fib, x:x )
//             }
            
//             pub fn run_fib_repeat (x:u64, n:u64) -> u64 {
//                 let mut st = &mut Engine::new() ;
//                 for _ in 1..(n-1) {
//                     memo!(st, fib, x:x );
//                 }
//                 memo!(st, fib, x:x )
//             }
            
//             #[test]
//             fn it_works() {
//                 assert_eq!(5 as u64, run_fib(5));
//             }
                        
//             #[bench]
//             fn bench_fib(b: &mut Bencher) {
//                 b.iter(|| test::black_box(run_fib(INPUT_SIZE)));
//             }
            
//             #[bench]
//             fn bench_fib_repeat(b: &mut Bencher) {
//                 b.iter(|| test::black_box(run_fib_repeat(INPUT_SIZE, REPEAT_COUNT)));
//             }
//         }
//     }
// }


// mod fact {
//     const INPUT_SIZE:u64 = 100;
//     const REPEAT_COUNT:u64 = 100;
    
//     #[cfg(test)]
//     mod no_caching {
//         use super::INPUT_SIZE;
//         use super::REPEAT_COUNT;

//         extern crate test;
//         use self::test::Bencher;
        
//         pub fn fact (x:u64) -> u64 {
//             if x == 0 { 1 } else { test::black_box(x) * fact(x-1) }
//         }
        
//         pub fn fact_repeat (x:u64, n:u64) -> u64 {
//             for _ in 1..(n-1) {
//                 test::black_box(fact(x));
//             }
//             fact(x)
//         }

//         #[test]
//         fn it_works() {
//             assert_eq!(120 as u64, fact(5));
//         }
        
//         #[bench]
//         fn bench_fact(b: &mut Bencher) {
//             b.iter(|| test::black_box(fact(INPUT_SIZE)));
//         }

//         #[bench]
//         fn bench_fact_repeat(b: &mut Bencher) {
//             b.iter(|| test::black_box(fact_repeat(INPUT_SIZE, REPEAT_COUNT)));
//         }
//     }

//     #[cfg(test)]
//     mod pure_caching {
//         use super::INPUT_SIZE;
//         use super::REPEAT_COUNT;

//         extern crate test;
//         use self::test::Bencher;

//         use std::rc::Rc;
        
//         use adapton::macros::* ;
//         use adapton::adapton_sigs::* ;
//         use adapton::engine::* ;
        
//         pub fn fact<A:Adapton> (st:&mut A, x:u64 ) -> u64 {
//             if x == 0 { 1 } else { x * (memo!(st, fact, x:x-1 )) }
//         }
        
//         pub fn run_fact (x:u64) -> u64 {
//             let mut st = &mut (Engine::new()) ;
//             memo!(st, fact, x:x )
//         }

//         pub fn run_fact_repeat (x:u64, n:u64) -> u64 {
//             let mut st = &mut (Engine::new()) ;
//             for _ in 1..(n-1) {
//                 memo!(st, fact, x:x );
//             }
//             memo!(st, fact, x:x )
//         }

//         #[test]
//         fn it_works() {
//             assert_eq!(120 as u64, run_fact(5));
//         }
        
//         #[bench]
//         fn bench_fact(b: &mut Bencher) {
//             b.iter(|| test::black_box(run_fact(INPUT_SIZE)));
//         }

//         #[bench]
//         fn bench_fact_repeat(b: &mut Bencher) {
//             b.iter(|| test::black_box(run_fact_repeat(INPUT_SIZE, REPEAT_COUNT)));
//         }
//     }
// }


// mod hourglass {
//     //const INPUT_ARRAY:Vec<u64> = vec![2; 64];
//     const REPEAT_COUNT:u64 = 100;

//     #[cfg(test)]
//     mod eager_ids {
//         //use super::INPUT_ARRAY;
//         use super::REPEAT_COUNT;
        
//         extern crate test;
//         use self::test::Bencher;

//         use std::rc::Rc;

//         use adapton::macros::* ;
//         use adapton::adapton_sigs::* ;
//         //use adapton::naive::* ;
//         use adapton::engine::* ;
//         use adapton::collection::* ;

//         // Thunks needs to *own* the arguments we give them.
//         fn ident<A:Adapton,T>(st:&mut A, x:T) -> T {x}
//         fn depend_mult<A:Adapton>(st:&mut A, x: Art<u64,A::Loc>,y: Art<u64,A::Loc>) -> u64 {
//             st.force(&x) * st.force(&y)
//         }
//         fn depend_add<A:Adapton>(st:&mut A, x: Art<u64,A::Loc>,y: Art<u64,A::Loc>) -> u64 {
//             //println!("depend_add:({:?},{:?})", x, y);
//             st.force(&x) + st.force(&y)
//         }
        
//         pub fn hourglass<A:Adapton> (st:&mut A) -> u64 {
//             let cells = vec![2;64];
//             let mut nodes = vec![];
//             for i in 0..64 {
//                 nodes.push(thunk!(st, ident, x:cells[i]));
//             }
//             let mut item_num = 0;
//             loop {
//                 if nodes.len() == 126 { break; }
//                 let first = nodes[item_num].clone();
//                 let second = nodes[item_num+1].clone();
//                 nodes.push(thunk!(st, depend_add, x:first, y:second));
//                 //println!("{} --> {}, {}", nodes.len()-1, item_num, item_num+1);
//                 if item_num < 122 { item_num += 2 } else { item_num += 1 }
//             }
//             let thk = &nodes[nodes.len()-1];
//             //println!("past checkpoint");
//             st.force(thk)
//         }

//         pub fn run_hourglass () -> u64 {
//             let mut st = &mut (Engine::new());
//             let res = hourglass(st);
//             //assert!(res == );
//             res
//         }

//         pub fn run_hourglass_repeat (n:u64) -> u64 {
//             let mut st = &mut (Engine::new());
//             for _ in 1..(n-1) {
//                 test::black_box(hourglass(st));
//             }
//             hourglass(st)
//         }

//         // output value uncertain, test is changing
//         // #[test]
//         // fn it_works() {
//         //     assert_eq!(2 as u64, run_hourglass());
//         // }

//         #[bench]
//         fn bench_hourglass(b: &mut Bencher) {
//             b.iter(|| test::black_box(run_hourglass()));
//         }

//         // Rewrite this as multiple changes in the input list
//         // #[bench]
//         // fn bench_hourglass_repeat(b: &mut Bencher) {
//         //     b.iter(|| test::black_box(run_hourglass_repeat(REPEAT_COUNT)));
//         // }
//     }
// }