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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
#[macro_export]
macro_rules! static_array {
(@accum (0, $($_ignored:expr),*) -> ($($body:tt)*))
=> {static_array!(@as_expr [$($body)*])};
(@accum (1, $($expr:expr),*) -> ($($body:tt)*))
=> {static_array!(@accum (0, $($expr),*) -> ($($body)* $($expr,)*))};
(@accum (2, $($expr:expr),*) -> ($($body:tt)*))
=> {static_array!(@accum (0, $($expr),*) -> ($($body)* $($expr,)* $($expr,)*))};
(@accum (4, $($expr:expr),*) -> ($($body:tt)*))
=> {static_array!(@accum (2, $($expr,)* $($expr),*) -> ($($body)*))};
(@accum (8, $($expr:expr),*) -> ($($body:tt)*))
=> {static_array!(@accum (4, $($expr,)* $($expr),*) -> ($($body)*))};
(@accum (16, $($expr:expr),*) -> ($($body:tt)*))
=> {static_array!(@accum (8, $($expr,)* $($expr),*) -> ($($body)*))};
(@accum (32, $($expr:expr),*) -> ($($body:tt)*))
=> {static_array!(@accum (16, $($expr,)* $($expr),*) -> ($($body)*))};
(@accum (64, $($expr:expr),*) -> ($($body:tt)*))
=> {static_array!(@accum (32, $($expr,)* $($expr),*) -> ($($body)*))};
(@accum (128, $($expr:expr),*) -> ($($body:tt)*))
=> {static_array!(@accum (64, $($expr,)* $($expr),*) -> ($($body)*))};
(@accum (256, $($expr:expr),*) -> ($($body:tt)*))
=> {static_array!(@accum (128, $($expr,)* $($expr),*) -> ($($body)*))};
(@accum (512, $($expr:expr),*) -> ($($body:tt)*))
=> {static_array!(@accum (256, $($expr,)* $($expr),*) -> ($($body)*))};
(@accum (1024, $($expr:expr),*) -> ($($body:tt)*))
=> {static_array!(@accum (512, $($expr,)* $($expr),*) -> ($($body)*))};
(@accum (2048, $($expr:expr),*) -> ($($body:tt)*))
=> {static_array!(@accum (1024, $($expr,)* $($expr),*) -> ($($body)*))};
(@accum (4096, $($expr:expr),*) -> ($($body:tt)*))
=> {static_array!(@accum (2048, $($expr,)* $($expr),*) -> ($($body)*))};
(@accum (8192, $($expr:expr),*) -> ($($body:tt)*))
=> {static_array!(@accum (4096, $($expr,)* $($expr),*) -> ($($body)*))};
(@as_expr $expr:expr) => {$expr};
[$expr:expr; $n:tt] => { static_array!(@accum ($n, $expr) -> ()) };
}
#[macro_export]
macro_rules! define_stack_allocator_traits(
($name : ident, global) => {
impl<'a, T: 'a> Default for $name<'a, T> {
fn default() -> Self {
return $name::<'a, T>{freelist : &mut[],};
}
}
define_stack_allocator_traits!($name, generic);
};
($name : ident, $freelist_size : tt, stack) => {
impl<'a, T: 'a> Default for $name<'a, T> {
fn default() -> Self {
return $name::<'a, T>{freelist : static_array!(&mut[]; $freelist_size)};
}
}
define_stack_allocator_traits!($name, generic);
};
($name : ident, heap) => {
impl<'a, T: 'a> Default for $name<'a, T> {
fn default() -> Self {
let v : Vec<&mut [T]> = Vec::new();
let b = v.into_boxed_slice();
return $name::<'a, T>{freelist : b};
}
}
define_stack_allocator_traits!($name, generic);
};
($name : ident, $freelist_size : tt, malloc) => {
define_stack_allocator_traits!($name, calloc);
};
($name : ident, $freelist_size : tt, calloc) => {
impl<'a, T: 'a> Default for $name<'a, T> {
fn default() -> Self {
return $name::<'a, T>{freelist : static_array!(&mut[]; $freelist_size)};
}
}
define_stack_allocator_traits!($name, generic);
};
($name : ident, generic) => {
impl<'a, T: 'a> SliceWrapper<&'a mut[T]> for $name<'a, T> {
fn slice(& self) -> & [&'a mut[T]] {
return & self.freelist;
}
}
impl<'a, T: 'a> SliceWrapperMut<&'a mut [T]> for $name<'a, T> {
fn slice_mut(& mut self) ->&mut [&'a mut [T]] {
return &mut self.freelist;
}
}
impl<'a, T: 'a> ops::Index<usize> for $name<'a, T> {
type Output = [T];
fn index<'b> (&'b self, _index : usize) -> &'b [T] {
return &self.freelist[_index];
}
}
impl<'a, T: 'a> ops::IndexMut<usize> for $name<'a, T> {
fn index_mut<'b>(&'b mut self, _index : usize) -> &'b mut [T] {
return &mut self.freelist[_index];
}
}
};
);
#[macro_export]
macro_rules! declare_stack_allocator_struct(
(@as_expr $expr : expr) => {$expr};
(@new_method $name : ident, $freelist_size : tt) => {
impl<'a, T: 'a> $name<'a, T> {
fn new_allocator(global_buffer : &'a mut [T],
initializer : fn(&mut[T])) -> StackAllocator<'a, T, $name<'a, T> > {
let mut retval = StackAllocator::<T, $name<T> > {
nop : &mut [],
system_resources : $name::<T>::default(),
free_list_start : declare_stack_allocator_struct!(@as_expr $freelist_size),
free_list_overflow_count : 0,
initialize : initializer,
};
retval.free_cell(AllocatedStackMemory::<T>{mem:global_buffer});
return retval;
}
}
};
(@new_calloc_method $name : ident, $freelist_size : tt) => {
impl<'a, T: 'a> $name<'a, T> {
fn new_allocator(mut global_buffer : &'a mut [T],
initializer : fn(&mut[T])) -> StackAllocator<'a, T, $name<'a, T> > {
let mut retval = StackAllocator::<T, $name<T> > {
nop : &mut [],
system_resources : $name::<T>::default(),
free_list_start : declare_stack_allocator_struct!(@as_expr $freelist_size),
free_list_overflow_count : 0,
initialize : initializer,
};
retval.free_cell(AllocatedStackMemory::<T>{mem:core::mem::replace(&mut global_buffer, &mut[])});
return retval;
}
}
};
($name :ident, $freelist_size : tt, malloc) => {
declare_stack_allocator_struct!($name, $freelist_size, calloc);
};
($name :ident, $freelist_size : tt, calloc) => {
struct $name<'a, T : 'a> {
freelist : [&'a mut [T]; declare_stack_allocator_struct!(@as_expr $freelist_size)],
}
define_stack_allocator_traits!($name,
$freelist_size,
calloc);
declare_stack_allocator_struct!( @new_calloc_method $name, $freelist_size);
};
($name :ident, $freelist_size : tt, stack) => {
struct $name<'a, T : 'a> {
freelist : [&'a mut [T];declare_stack_allocator_struct!(@as_expr $freelist_size)],
}
define_stack_allocator_traits!($name,
$freelist_size,
stack);
declare_stack_allocator_struct!( @new_method $name, $freelist_size);
};
($name :ident, $freelist_size : expr, global) => {
struct $name <'a, T: 'a> {freelist : &'a mut [&'a mut [T]]}
define_stack_allocator_traits!($name, global);
impl<'a, T: 'a> $name<'a, T> {
fn new_allocator(initializer : fn (&mut[T])) -> StackAllocator<'a, T, $name<'a, T> > {
return StackAllocator::<T, $name<T> > {
nop : &mut [],
system_resources : $name::<T>::default(),
free_list_start : 0,
free_list_overflow_count : 0,
initialize : initializer,
};
}
}
};
);
#[macro_export]
macro_rules! bind_global_buffers_to_allocator(
($allocator : expr, $buffer : ident, $T : ty) => {
$allocator.free_list_start = $buffer::freelist.len();
$allocator.system_resources.freelist = &mut $buffer::freelist;
$allocator.free_cell(AllocatedStackMemory::<$T>{mem:&mut $buffer::heap});
};
);
#[macro_export]
macro_rules! define_allocator_memory_pool(
(@as_expr $expr:expr) => {$expr};
($freelist_size : tt, $T : ty, [0; $heap_size : expr], calloc) => {
alloc_no_stdlib::CallocBackingStore::<$T>::new($heap_size, alloc_no_stdlib::AllocatorC::Calloc(calloc), free, true);
};
($freelist_size : tt, $T : ty, [0; $heap_size : expr], calloc_no_free) => {
alloc_no_stdlib::CallocBackingStore::<$T>::new($heap_size, alloc_no_stdlib::AllocatorC::Calloc(calloc), free, false);
};
($freelist_size : tt, $T : ty, [0; $heap_size : expr], malloc) => {
alloc_no_stdlib::CallocBackingStore::<$T>::new($heap_size, alloc_no_stdlib::AllocatorC::Malloc(malloc), free, true);
};
($freelist_size : tt, $T : ty, [0; $heap_size : expr], malloc_no_free) => {
alloc_no_stdlib::CallocBackingStore::<$T>::new($heap_size, alloc_no_stdlib::AllocatorC::Malloc(malloc), free, false);
};
($freelist_size : tt, $T : ty, [$default_value : expr; $heap_size : expr], heap) => {
(vec![$default_value; $heap_size]).into_boxed_slice();
};
($freelist_size : tt, $T : ty, [$default_value : expr; $heap_size : expr], stack) => {
[$default_value; $heap_size];
};
($freelist_size : tt, $T : ty, [$default_value : expr; $heap_size : expr], global, $name : ident) => {
pub mod $name {
pub static mut freelist : [&'static mut [$T];
define_allocator_memory_pool!(@as_expr $freelist_size)]
= static_array!(&mut[]; $freelist_size);
pub static mut heap : [$T; $heap_size] = [$default_value; $heap_size];
}
};
);