Skip to content

Commit 31f4ca0

Browse files
danielrhdanielrh
committedApr 3, 2016
simplified stack allocator to use a contiguous free array rather than a free list: the result
1 parent 3b341cc commit 31f4ca0

File tree

10 files changed

+204
-244
lines changed

10 files changed

+204
-244
lines changed
 

‎.gitignore

+2-1
Original file line numberDiff line numberDiff line change
@@ -1 +1,2 @@
1-
Cargo.lock
1+
Cargo.lock
2+
target

‎src/allocated_memory/mod.rs

+7-25
Original file line numberDiff line numberDiff line change
@@ -1,37 +1,19 @@
11
extern crate core;
2-
pub mod traits;
32
use core::ops;
43

54

6-
pub struct AllocatedStackMemory<'a, T:'a> {
7-
pub mem : &'a mut [T],
8-
pub next : Option<&'a mut AllocatedStackMemory <'a, T> >,
5+
pub trait SliceWrapper<T> {
6+
fn slice(& self) -> & [T];
97
}
108

11-
impl<'a, T: 'a> ops::Index<usize> for & 'a mut AllocatedStackMemory<'a, T> {
12-
type Output = T;
13-
fn index<'b>(&'b self, _index : usize) -> &'b T {
14-
return &self.mem[_index];
15-
}
9+
pub trait SliceWrapperMut<T> {
10+
fn slice_mut (&mut self) -> & mut [T];
1611
}
1712

18-
impl<'a, T: 'a> ops::IndexMut<usize> for &'a mut AllocatedStackMemory<'a, T> {
19-
fn index_mut<'b>(&'b mut self, _index : usize) -> &'b mut T {
20-
return &mut self.mem[_index];
21-
}
13+
pub trait AllocatedSlice<T>
14+
: SliceWrapperMut<T> + SliceWrapper<T> + ops::IndexMut<usize> + ops::Index<usize> {
2215
}
2316

24-
impl<'a, T: 'a> traits::SliceWrapper<T> for & 'a mut AllocatedStackMemory<'a, T> {
25-
fn slice(& self) -> & [T] {
26-
return & self.mem;
27-
}
28-
}
17+
impl<T, U> AllocatedSlice<T> for U where U : SliceWrapperMut<T> + SliceWrapper<T> + ops::IndexMut<usize> + ops::Index<usize> {
2918

30-
impl<'a, T: 'a> traits::SliceWrapperMut<T> for &'a mut AllocatedStackMemory<'a, T> {
31-
fn slice_mut(& mut self) ->& mut [T] {
32-
return &mut self.mem;
33-
}
3419
}
35-
36-
37-

‎src/allocated_memory/traits/mod.rs

-19
This file was deleted.

‎src/allocated_stack_memory.rs

+37
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,37 @@
1+
extern crate core;
2+
use super::allocated_memory::SliceWrapper;
3+
use super::allocated_memory::SliceWrapperMut;
4+
use core::ops;
5+
6+
7+
pub struct AllocatedStackMemory<'a, T:'a> {
8+
pub mem : &'a mut [T],
9+
}
10+
11+
impl<'a, T: 'a> ops::Index<usize> for AllocatedStackMemory<'a, T> {
12+
type Output = T;
13+
fn index<'b>(&'b self, _index : usize) -> &'b T {
14+
return &self.mem[_index];
15+
}
16+
}
17+
18+
impl<'a, T: 'a> ops::IndexMut<usize> for AllocatedStackMemory<'a, T> {
19+
fn index_mut<'b>(&'b mut self, _index : usize) -> &'b mut T {
20+
return &mut self.mem[_index];
21+
}
22+
}
23+
24+
impl<'a, T: 'a> SliceWrapper<T> for AllocatedStackMemory<'a, T> {
25+
fn slice(& self) -> & [T] {
26+
return & self.mem;
27+
}
28+
}
29+
30+
impl<'a, T: 'a> SliceWrapperMut<T> for AllocatedStackMemory<'a, T> {
31+
fn slice_mut(& mut self) ->& mut [T] {
32+
return &mut self.mem;
33+
}
34+
}
35+
36+
37+

‎src/allocator/mod.rs

+7
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,7 @@
1+
2+
pub trait Allocator<T> {
3+
type AllocatedMemory : super::AllocatedSlice<T>;
4+
fn alloc_cell(&mut self, len : usize) -> Self::AllocatedMemory;
5+
fn free_cell(&mut self, data : Self::AllocatedMemory);
6+
}
7+

‎src/bin/example.rs

+42-28
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
#[macro_use]
22
extern crate alloc_no_stdlib as alloc;
33
extern crate core;
4-
4+
use core::ops;
55
mod heap_alloc;
66

77
pub use heap_alloc::HeapAllocator;
@@ -15,9 +15,36 @@ use alloc::SliceWrapperMut;
1515
use alloc::AllocatedStackMemory;
1616
use alloc::Allocator;
1717
use alloc::StackAllocator;
18-
use alloc::AllocatorStackState;
1918

19+
struct StackAllocatedFreelist4<'a, T : 'a> {
20+
freelist : [&'a mut [T]; 4],
21+
}
22+
23+
24+
impl<'a, T: 'a> alloc::SliceWrapper<&'a mut[T]> for StackAllocatedFreelist4<'a, T> {
25+
fn slice(& self) -> & [&'a mut[T]] {
26+
return & self.freelist;
27+
}
28+
}
29+
30+
impl<'a, T: 'a> alloc::SliceWrapperMut<&'a mut [T]> for StackAllocatedFreelist4<'a, T> {
31+
fn slice_mut(& mut self) ->&mut [&'a mut [T]] {
32+
return &mut self.freelist;
33+
}
34+
}
35+
36+
impl<'a, T: 'a> ops::Index<usize> for StackAllocatedFreelist4<'a, T> {
37+
type Output = [T];
38+
fn index<'b> (&'b self, _index : usize) -> &'b [T] {
39+
return &self.freelist[_index];
40+
}
41+
}
2042

43+
impl<'a, T: 'a> ops::IndexMut<usize> for StackAllocatedFreelist4<'a, T> {
44+
fn index_mut<'b>(&'b mut self, _index : usize) -> &'b mut [T] {
45+
return &mut self.freelist[_index];
46+
}
47+
}
2148

2249

2350
extern {
@@ -27,38 +54,24 @@ fn main() {
2754
//let mut global_buffer : [u8; 1024 * 4096] = [0;4096*1024];
2855
let max_memory_pool_size : usize = 1024 * 1024 * 200;
2956

30-
/*
31-
let global_buffer_vec : Vec<u8> = vec![0; max_memory_pool_size];
32-
//let global_buffer_vec = std::iter::repeat(0u8).take(max_memory_pool_size).collect::<Vec<u8>>();
33-
let mut global_buffer_box = global_buffer_vec.into_boxed_slice();
57+
//// let global_buffer_vec : Vec<u8> = vec![0; max_memory_pool_size];
58+
//// //let global_buffer_vec = std::iter::repeat(0u8).take(max_memory_pool_size).collect::<Vec<u8>>();
59+
//// let mut global_buffer_box = global_buffer_vec.into_boxed_slice();
3460

35-
let mut global_buffer = &mut *global_buffer_box;
36-
*/
61+
//// let mut global_buffer = &mut *global_buffer_box;
3762
let allocated_mem = unsafe {calloc(max_memory_pool_size, core::mem::size_of::<u8>())};
3863
let global_ptr : *mut u8 = unsafe {core::mem::transmute(allocated_mem)};
3964
let mut global_buffer = unsafe {core::slice::from_raw_parts_mut(global_ptr, max_memory_pool_size)};
40-
/*
41-
for item in &*global_buffer {
42-
assert_eq!(*item, 0u8);
43-
}
44-
*/
45-
let mut cells_backing_store = static_array!(AllocatedStackMemory::<u8>{mem:&mut[], next:None}; 4096);
46-
let mut ags = StackAllocator::<u8, AllocatorStackState<u8> > {
47-
system_resources : AllocatorStackState::<u8> {
48-
_cells : &mut [],
65+
let mut ags = StackAllocator::<u8, StackAllocatedFreelist4<u8> > {
66+
nop : &mut [],
67+
system_resources : StackAllocatedFreelist4::<u8> {
68+
freelist : static_array!(&mut[]; 4),
4969
},
50-
glob : None,
70+
free_list_start : 4,
71+
free_list_overflow_count : 0,
5172
};
52-
let mut cells = &mut cells_backing_store[..];
53-
let (mut sentinel, mut normal_cells) = cells.split_at_mut(1);
54-
sentinel[0].mem = global_buffer;
55-
ags.glob = Some(&mut sentinel[0]);
56-
for _i in 0..normal_cells.len() {
57-
let n_cells = core::mem::replace(&mut normal_cells, &mut []);
58-
let (mut cell0, mut cell1) = n_cells.split_at_mut(1);
59-
ags.free_cell(&mut cell0[0]);
60-
normal_cells = cell1;
61-
}
73+
ags.free_cell(AllocatedStackMemory::<u8>{mem:global_buffer});
74+
6275
{
6376
let mut x = ags.alloc_cell(9999);
6477
x.slice_mut()[0] = 4;
@@ -78,6 +91,7 @@ fn main() {
7891
println!("x[0] = {:?} z[0] = {:?} z[1] = {:?} r3[0] = {:?} r3[1] = {:?}", x.mem[0], z.mem[0], z.mem[1], reget_three[0], reget_three.slice()[1]);
7992
let mut _z = ags.alloc_cell(1);
8093
}
94+
8195
let mut halloc : HeapAllocator<u8> = HeapAllocator::<u8>{default_value: 0};
8296
for _i in 1..10 { // heap test
8397
let mut x = halloc.alloc_cell(100000);

‎src/bin/tests.rs

+2
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,5 @@
1+
#![allow(unused_imports)]
2+
#[cfg(test)]
13
extern crate core;
24
use alloc::Allocator;
35
use super::HeapAllocator;

‎src/lib.rs

+5-5
Original file line numberDiff line numberDiff line change
@@ -2,14 +2,14 @@
22

33
mod allocated_memory;
44
mod stack_allocator;
5+
mod allocated_stack_memory;
56
pub mod init;
67
mod tests;
7-
pub use allocated_memory::traits::SliceWrapper;
8-
pub use allocated_memory::traits::SliceWrapperMut;
9-
pub use allocated_memory::traits::AllocatedSlice;
8+
pub use allocated_memory::SliceWrapper;
9+
pub use allocated_memory::SliceWrapperMut;
10+
pub use allocated_memory::AllocatedSlice;
1011

11-
pub use allocated_memory::AllocatedStackMemory;
12+
pub use allocated_stack_memory::AllocatedStackMemory;
1213
pub use stack_allocator::Allocator;
1314
pub use stack_allocator::StackAllocator;
14-
pub use stack_allocator::AllocatorStackState;
1515

‎src/stack_allocator.rs

+56-139
Original file line numberDiff line numberDiff line change
@@ -1,162 +1,79 @@
11
extern crate core;
2-
use allocated_memory;
3-
use allocated_memory::AllocatedStackMemory;
2+
use super::allocated_memory;
3+
use super::allocated_stack_memory::AllocatedStackMemory;
44

55
pub trait Allocator<T> {
6-
type AllocatedMemory : allocated_memory::traits::AllocatedSlice<T>;
6+
type AllocatedMemory : allocated_memory::AllocatedSlice<T>;
77
fn alloc_cell(&mut self, len : usize) -> Self::AllocatedMemory;
88
fn free_cell(&mut self, data : Self::AllocatedMemory);
99
}
1010

1111

12-
pub trait SystemMemoryPool<'a, T> {
13-
fn add_slices(&mut self, input : &mut Option<& 'a mut AllocatedStackMemory<'a, T> >);
14-
fn add_memory(&mut self, input : &mut Option<& 'a mut AllocatedStackMemory<'a, T> >, min_length : usize);
15-
}
16-
17-
1812

19-
20-
pub struct StackAllocator<'a, T :'a, U : SystemMemoryPool<'a, T> > {
13+
pub struct StackAllocator<'a,
14+
T :'a,
15+
U : allocated_memory::AllocatedSlice<&'a mut [T]> > {
16+
pub nop : &'a mut [T],
2117
pub system_resources : U,
22-
pub glob : Option<&'a mut AllocatedStackMemory <'a, T> >,
18+
pub free_list_start : usize,
19+
pub free_list_overflow_count : usize,
2320
}
2421

2522

26-
fn remove_cur<'a, T>(mut iter : &mut Option<&mut AllocatedStackMemory<'a, T> >) -> &'a mut AllocatedStackMemory<'a, T> {
27-
match *iter {
28-
Some(ref mut glob_next) => {
29-
let rest : Option<&'a mut AllocatedStackMemory<'a, T> >;
30-
match glob_next.next {
31-
Some(ref mut root_cell) => rest = core::mem::replace(&mut root_cell.next, None),
32-
None => rest = None,
33-
}
34-
match core::mem::replace(&mut glob_next.next, rest) {
35-
Some(mut root_cell) => return root_cell,
36-
None => panic!("Empty list"),
23+
impl<'a, T, U : allocated_memory::AllocatedSlice<&'a mut[T]> >
24+
Allocator<T> for StackAllocator <'a, T, U> {
25+
type AllocatedMemory = AllocatedStackMemory<'a, T>;
26+
fn alloc_cell(self : &mut StackAllocator<'a, T, U>,
27+
len : usize) -> AllocatedStackMemory<'a, T> {
28+
let mut index : usize = self.free_list_start;
29+
let mut found : bool = false;
30+
for free_resource in self.system_resources.slice()[self.free_list_start..].iter() {
31+
if free_resource.len() >= len {
32+
found = true;
33+
break;
3734
}
38-
},
39-
None => panic!("List not initialized"),
40-
}
41-
}
42-
43-
44-
fn remove_search_recursive<'a, T : 'a> (mut node : &mut Option<&mut AllocatedStackMemory <'a, T> >,
45-
searchmin : usize,
46-
searchmax : usize) -> &'a mut AllocatedStackMemory<'a, T> {
47-
let mut found : bool = false;
48-
{
49-
match *node {
50-
Some(ref mut cur_cell) => {
51-
match cur_cell.next {
52-
Some(ref item) => {
53-
let len = item.mem.len();
54-
if (len >= searchmin && (searchmax ==0 || len < searchmax))
55-
|| len == 0 || !item.next.is_some() {
56-
found = true;
57-
}
58-
},
59-
None => panic!("Too many outstanding allocated items"),
60-
}
61-
if !found {
62-
return remove_search_recursive(&mut cur_cell.next, searchmin, searchmax);
63-
}
64-
},
65-
None => panic!("Too many outstanding allocated items"),
35+
index += 1;
6636
}
67-
}
68-
assert!(found);
69-
return remove_cur(node);
70-
}
71-
72-
fn return_slice_to<'a, T> (mut node : &mut Option<&mut AllocatedStackMemory <'a, T> >,
73-
mut val : & 'a mut AllocatedStackMemory<'a, T>) {
74-
match *node {
75-
Some(ref mut glob_next) => {
76-
match core::mem::replace(&mut glob_next.next ,None) {
77-
Some(mut x) => {
78-
let _discard = core::mem::replace(&mut val.next, Some(x));
79-
},
80-
None => {},
81-
}
82-
glob_next.next = Some(val);
83-
},
84-
None => panic!("Allocator not initialized"),
85-
}
86-
}
87-
88-
impl<'a, T, U : SystemMemoryPool<'a, T> > StackAllocator <'a, T, U> {
89-
fn alloc_cell_directive(self : &mut StackAllocator<'a, T, U>, len : usize,
90-
best_match: bool) -> &'a mut AllocatedStackMemory<'a, T> {
91-
let lower_bound : usize;
92-
let upper_bound: usize;
93-
if best_match {
94-
lower_bound = len;
95-
upper_bound = len * 3 / 2;
96-
} else {
97-
lower_bound = 0;
98-
upper_bound = 0;
37+
if !found {
38+
panic!("OOM");
9939
}
100-
101-
let mut retval = remove_search_recursive(&mut self.glob, lower_bound, upper_bound);
102-
if retval.mem.len() < len {
103-
let oom : bool;
104-
match self.glob {
105-
Some(ref mut sentinel) => {
106-
oom = sentinel.mem.len() < len;
107-
},
108-
None => panic!("Uninitialized allocator"),
109-
}
110-
if oom {
111-
self.system_resources.add_memory(&mut self.glob, len);
112-
}
113-
match self.glob {
114-
Some(ref mut sentinel) => {
115-
let mut current_mem = core::mem::replace(&mut sentinel.mem, &mut[]);
116-
if current_mem.len() < len {
117-
panic!("OOM");
118-
}
119-
let (mut new_chunk, mut remaining_mem) = current_mem.split_at_mut(len);
120-
sentinel.mem = remaining_mem;
121-
retval.mem = new_chunk;
122-
},
123-
None => panic!("Uninitalized allocator"),
40+
let mut available_slice = core::mem::replace(&mut self.system_resources.slice_mut()[index],
41+
&mut[]);
42+
if available_slice.len() < len + 32 { // we don't want really small wasted slices
43+
// we must assign free_list_start
44+
if index != self.free_list_start {
45+
assert!(index > self.free_list_start);
46+
let mut farthest_free_list = core::mem::replace(
47+
&mut self.system_resources.slice_mut()[self.free_list_start],
48+
&mut []);
49+
core::mem::replace(&mut self.system_resources.slice_mut()[index],
50+
farthest_free_list);
12451
}
125-
}
126-
return retval;
127-
}
128-
fn no_slices_left(self :&StackAllocator<'a, T, U>) -> bool {
129-
match self.glob {
130-
Some(ref glob_next) => return !glob_next.next.is_some(),
131-
None => return true,
52+
self.free_list_start += 1;
53+
return AllocatedStackMemory::<'a, T>{mem:available_slice};
54+
} else { // the memory allocated was not the entire range of items. Split and move on
55+
let (mut retval, return_to_sender) = available_slice.split_at_mut(len);
56+
core::mem::replace(&mut self.system_resources.slice_mut()[index], return_to_sender);
57+
return AllocatedStackMemory::<'a, T>{mem:retval};
13258
}
13359
}
134-
}
135-
impl<'a, T, U : SystemMemoryPool<'a, T> >
136-
Allocator<T> for StackAllocator <'a, T, U> {
137-
type AllocatedMemory = &'a mut AllocatedStackMemory<'a, T>;
138-
fn alloc_cell(self : &mut StackAllocator<'a, T, U>,
139-
len : usize) -> &'a mut AllocatedStackMemory<'a, T> {
140-
if self.no_slices_left() {
141-
self.system_resources.add_slices(&mut self.glob);
142-
}
143-
return self.alloc_cell_directive(len, true);
144-
}
14560
fn free_cell(self : &mut StackAllocator<'a, T, U>,
146-
mut val : & 'a mut AllocatedStackMemory<'a, T>) {
147-
return_slice_to(&mut self.glob, val)
61+
mut val : AllocatedStackMemory<'a, T>) {
62+
if self.free_list_start > 0 {
63+
self.free_list_start -=1;
64+
core::mem::replace(&mut self.system_resources.slice_mut()[self.free_list_start],
65+
val.mem);
66+
} else {
67+
for _i in 0..3 {
68+
self.free_list_overflow_count += 1;
69+
self.free_list_overflow_count %= self.system_resources.slice().len();
70+
if self.system_resources.slice()[self.free_list_overflow_count].len() < val.mem.len() {
71+
core::mem::replace(&mut self.system_resources.slice_mut()[self.free_list_overflow_count],
72+
val.mem);
73+
return;
74+
}
75+
}
76+
}
14877
}
14978
}
15079

151-
pub struct AllocatorStackState<'a, T : 'a>{
152-
pub _cells : &'a mut [AllocatedStackMemory<'a, T>],
153-
}
154-
155-
impl<'a, T> SystemMemoryPool<'a, T> for AllocatorStackState<'a, T> {
156-
fn add_slices(self : &mut AllocatorStackState<'a, T>, _x : & mut Option<&'a mut AllocatedStackMemory<'a, T> >) {
157-
panic!("Out of Slices");
158-
}
159-
fn add_memory(self : &mut AllocatorStackState<'a, T>, _x : & mut Option<&'a mut AllocatedStackMemory<'a, T> >, _min_len : usize) {
160-
panic!("Out of Memory");
161-
}
162-
}

‎src/tests.rs

+46-27
Original file line numberDiff line numberDiff line change
@@ -1,36 +1,55 @@
1+
#![allow(unused_imports)]
2+
#![allow(dead_code)]
13
#[cfg(test)]
2-
3-
use super::{Allocator, SliceWrapperMut,
4-
StackAllocator, AllocatedStackMemory, AllocatorStackState};
54
extern crate core;
5+
use core::ops;
6+
use super::{Allocator, SliceWrapperMut, SliceWrapper,
7+
StackAllocator, AllocatedStackMemory};
8+
9+
struct StackAllocatedFreelist4<'a, T : 'a> {
10+
freelist : [&'a mut [T]; 4],
11+
}
12+
13+
14+
impl<'a, T: 'a> SliceWrapper<&'a mut[T]> for StackAllocatedFreelist4<'a, T> {
15+
fn slice(& self) -> & [&'a mut[T]] {
16+
return & self.freelist;
17+
}
18+
}
19+
20+
impl<'a, T: 'a> SliceWrapperMut<&'a mut [T]> for StackAllocatedFreelist4<'a, T> {
21+
fn slice_mut(& mut self) ->&mut [&'a mut [T]] {
22+
return &mut self.freelist;
23+
}
24+
}
25+
26+
impl<'a, T: 'a> ops::Index<usize> for StackAllocatedFreelist4<'a, T> {
27+
type Output = [T];
28+
fn index<'b> (&'b self, _index : usize) -> &'b [T] {
29+
return &self.freelist[_index];
30+
}
31+
}
32+
33+
impl<'a, T: 'a> ops::IndexMut<usize> for StackAllocatedFreelist4<'a, T> {
34+
fn index_mut<'b>(&'b mut self, _index : usize) -> &'b mut [T] {
35+
return &mut self.freelist[_index];
36+
}
37+
}
38+
39+
640
#[test]
741
fn integration_test() {
842
let mut global_buffer : [u8; 65536] = [0; 65536];
9-
let mut cells_backing_store : [AllocatedStackMemory<u8>; 8]
10-
= [AllocatedStackMemory::<u8>{mem:&mut[], next:None},
11-
AllocatedStackMemory::<u8>{mem:&mut[], next:None},
12-
AllocatedStackMemory::<u8>{mem:&mut[], next:None},
13-
AllocatedStackMemory::<u8>{mem:&mut[], next:None},
14-
AllocatedStackMemory::<u8>{mem:&mut[], next:None},
15-
AllocatedStackMemory::<u8>{mem:&mut[], next:None},
16-
AllocatedStackMemory::<u8>{mem:&mut[], next:None},
17-
AllocatedStackMemory::<u8>{mem:&mut[], next:None}];
18-
let mut ags = StackAllocator::<u8, AllocatorStackState<u8> > {
19-
system_resources : AllocatorStackState::<u8> {
20-
_cells : &mut [],
43+
let mut ags = StackAllocator::<u8, StackAllocatedFreelist4<u8> > {
44+
nop : &mut [],
45+
system_resources : StackAllocatedFreelist4::<u8> {
46+
freelist : [&mut[],&mut[],&mut[],&mut[],],
2147
},
22-
glob : None,
48+
free_list_start : 4,
49+
free_list_overflow_count : 0,
2350
};
24-
let mut cells = &mut cells_backing_store[..];
25-
let (mut sentinel, mut normal_cells) = cells.split_at_mut(1);
26-
sentinel[0].mem = &mut global_buffer;
27-
ags.glob = Some(&mut sentinel[0]);
28-
for _i in 0..normal_cells.len() {
29-
let n_cells = core::mem::replace(&mut normal_cells, &mut []);
30-
let (mut cell0, mut cell1) = n_cells.split_at_mut(1);
31-
ags.free_cell(&mut cell0[0]);
32-
normal_cells = cell1;
33-
}
51+
ags.free_cell(AllocatedStackMemory::<u8>{mem:&mut global_buffer});
52+
3453
{
3554
let mut x = ags.alloc_cell(9999);
3655
x.slice_mut()[0] = 4;
@@ -48,7 +67,7 @@ fn integration_test() {
4867
reget_three.slice_mut()[1] = 9;
4968
//y.mem[0] = 6; // <-- this is an error (use after free)
5069
assert_eq!(x[0], 4);
51-
assert_eq!(z[0], 5);
70+
assert_eq!(z[0], 6);
5271
assert_eq!(z[1], 8);
5372
assert_eq!(reget_three[0], 0);
5473
assert_eq!(reget_three[1], 9);

0 commit comments

Comments
 (0)
Please sign in to comment.