tagged-pointer-as-enum 1.0.0

A set of structs, traits and macros to implement tagged pointers.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

use tagged_pointer_as_enum::{tagged_enum, TaggedPointerValue};

#[cfg(feature = "bench")]
extern crate criterion;

#[cfg(feature = "bench")]
use criterion::{black_box, criterion_group, criterion_main, Criterion};

struct None;
impl TaggedPointerValue for None {}

enum Native {
    None(None),

    U8(Box<u8>),
    U16(Box<u16>),
    U32(Box<u32>),
    U64(Box<u64>),
    I8(Box<i8>),
    I16(Box<i16>),
    I32(Box<i32>),
}

impl Default for Native {
    fn default() -> Self {
        Native::None(None)
    }
}

tagged_enum! {
    enum Tagged {
        bits = 8;

        None(None),

        U8(Box<u8>),
        U16(Box<u16>),
        U32(Box<u32>),
        U64(Box<u64>),
        I8(Box<i8>),
        I16(Box<i16>),
        I32(Box<i32>),
    }
}

impl Default for Tagged {
    fn default() -> Self {
        Tagged::None(None)
    }
}

trait ForEachVariant {
    fn for_each_variant<F>(f: F)
    where
        F: FnMut(Self),
        Self: Sized;
}

impl ForEachVariant for Native {
    fn for_each_variant<F>(mut f: F)
    where
        F: FnMut(Self),
    {
        f(Native::U8(Box::new(10)));
        f(Native::U16(Box::new(1000)));
        f(Native::U32(Box::new(100_000)));
        f(Native::U64(Box::new(100_000)));
        f(Native::I8(Box::new(-10)));
        f(Native::I16(Box::new(-1000)));
        f(Native::I32(Box::new(-100_000)));
    }
}

impl ForEachVariant for Tagged {
    fn for_each_variant<F>(mut f: F)
    where
        F: FnMut(Self),
    {
        f(Tagged::U8(Box::new(10)));
        f(Tagged::U16(Box::new(1000)));
        f(Tagged::U32(Box::new(100_000)));
        f(Tagged::U64(Box::new(100_000)));
        f(Tagged::I8(Box::new(-10)));
        f(Tagged::I16(Box::new(-1000)));
        f(Tagged::I32(Box::new(-100_000)));
    }
}

fn work<T>()
where
    T: ForEachVariant + Default,
{
    let mut stack = Vec::with_capacity(7 * 50);

    for _ in 0..50 {
        T::for_each_variant(|v| {
            stack.push(v);
            let len = stack.len();
            std::mem::take(&mut stack[len - 1]);
        });
    }

    #[cfg(feature = "bench")]
    black_box(stack);
}

#[inline(never)]
#[cfg(feature = "bench")]
fn native_enum(c: &mut Criterion) {
    c.bench_function("native_enum", |b| b.iter(|| work::<Native>()));
}

#[inline(never)]
#[cfg(feature = "bench")]
fn tagged_enum(c: &mut Criterion) {
    c.bench_function("tagged_enum", |b| b.iter(|| work::<Tagged>()));
}

#[cfg(feature = "bench")]
criterion_group!(alloc, native_enum, tagged_enum);
#[cfg(feature = "bench")]
criterion_main!(alloc);

#[cfg(not(feature = "bench"))]
fn main() {}