Debian Codegraph @

.cargo/vendor/bytes/tests/test_bytes_vec_alloc.rs

raw
1 #![cfg(not(miri))]
2 use std::alloc::{GlobalAlloc, Layout, System};
3 use std::ptr::null_mut;
4 use std::sync::atomic::{AtomicPtr, AtomicUsize, Ordering};
5
6 use bytes::{Buf, Bytes};
7
8 #[global_allocator]
9 static LEDGER: Ledger = Ledger::new();
10
11 const LEDGER_LENGTH: usize = 1024 * 1024;
12
13 struct Ledger {
14 alloc_table: [(AtomicPtr<u8>, AtomicUsize); LEDGER_LENGTH],
15 }
16
17 impl Ledger {
18 const fn new() -> Self {
19 const ELEM: (AtomicPtr<u8>, AtomicUsize) =
20 (AtomicPtr::new(null_mut()), AtomicUsize::new(0));
21 let alloc_table = [ELEM; LEDGER_LENGTH];
22
23 Self { alloc_table }
24 }
25
26 /// Iterate over our table until we find an open entry, then insert into said entry
27 fn insert(&self, ptr: *mut u8, size: usize) {
28 for (entry_ptr, entry_size) in self.alloc_table.iter() {
29 // SeqCst is good enough here, we don't care about perf, i just want to be correct!
30 if entry_ptr
31 .compare_exchange(null_mut(), ptr, Ordering::SeqCst, Ordering::SeqCst)
32 .is_ok()
33 {
34 entry_size.store(size, Ordering::SeqCst);
35 return;
36 }
37 }
38
39 panic!("Ledger ran out of space.");
40 }
41
42 fn remove(&self, ptr: *mut u8) -> usize {
43 for (entry_ptr, entry_size) in self.alloc_table.iter() {
44 // set the value to be something that will never try and be deallocated, so that we
45 // don't have any chance of a race condition
46 //
47 // dont worry, LEDGER_LENGTH is really long to compensate for us not reclaiming space
48 if entry_ptr
49 .compare_exchange(
50 ptr,
51 invalid_ptr(usize::MAX),
52 Ordering::SeqCst,
53 Ordering::SeqCst,
54 )
55 .is_ok()
56 {
57 return entry_size.load(Ordering::SeqCst);
58 }
59 }
60
61 panic!("Couldn't find a matching entry for {:x?}", ptr);
62 }
63 }
64
65 unsafe impl GlobalAlloc for Ledger {
66 unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
67 let size = layout.size();
68 let ptr = System.alloc(layout);
69 self.insert(ptr, size);
70 ptr
71 }
72
73 unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
74 let orig_size = self.remove(ptr);
75
76 if orig_size != layout.size() {
77 panic!(
78 "bad dealloc: alloc size was {}, dealloc size is {}",
79 orig_size,
80 layout.size()
81 );
82 } else {
83 System.dealloc(ptr, layout);
84 }
85 }
86 }
87
88 #[test]
89 fn test_bytes_advance() {
90 let mut bytes = Bytes::from(vec![10, 20, 30]);
91 bytes.advance(1);
92 drop(bytes);
93 }
94
95 #[test]
96 fn test_bytes_truncate() {
97 let mut bytes = Bytes::from(vec![10, 20, 30]);
98 bytes.truncate(2);
99 drop(bytes);
100 }
101
102 #[test]
103 fn test_bytes_truncate_and_advance() {
104 let mut bytes = Bytes::from(vec![10, 20, 30]);
105 bytes.truncate(2);
106 bytes.advance(1);
107 drop(bytes);
108 }
109
110 /// Returns a dangling pointer with the given address. This is used to store
111 /// integer data in pointer fields.
112 #[inline]
113 fn invalid_ptr<T>(addr: usize) -> *mut T {
114 let ptr = std::ptr::null_mut::<u8>().wrapping_add(addr);
115 debug_assert_eq!(ptr as usize, addr);
116 ptr.cast::<T>()
117 }
118
119 #[test]
120 fn test_bytes_into_vec() {
121 let vec = vec![33u8; 1024];
122
123 // Test cases where kind == KIND_VEC
124 let b1 = Bytes::from(vec.clone());
125 assert_eq!(Vec::from(b1), vec);
126
127 // Test cases where kind == KIND_ARC, ref_cnt == 1
128 let b1 = Bytes::from(vec.clone());
129 drop(b1.clone());
130 assert_eq!(Vec::from(b1), vec);
131
132 // Test cases where kind == KIND_ARC, ref_cnt == 2
133 let b1 = Bytes::from(vec.clone());
134 let b2 = b1.clone();
135 assert_eq!(Vec::from(b1), vec);
136
137 // Test cases where vtable = SHARED_VTABLE, kind == KIND_ARC, ref_cnt == 1
138 assert_eq!(Vec::from(b2), vec);
139
140 // Test cases where offset != 0
141 let mut b1 = Bytes::from(vec.clone());
142 let b2 = b1.split_off(20);
143
144 assert_eq!(Vec::from(b2), vec[20..]);
145 assert_eq!(Vec::from(b1), vec[..20]);
146 }