1use crate::utils::BitField;
2
3pub type mi_thread_free_t = usize;
4
5pub type mi_page_kind_t = cty::c_uint;
6pub const mi_page_kind_MI_PAGE_SMALL: mi_page_kind_t = 0;
7pub const mi_page_kind_MI_PAGE_MEDIUM: mi_page_kind_t = 1;
8pub const mi_page_kind_MI_PAGE_LARGE: mi_page_kind_t = 2;
9pub const mi_page_kind_MI_PAGE_HUGE: mi_page_kind_t = 3;
10
11#[repr(C)]
12#[derive(Copy, Clone)]
13pub struct mi_page_t {
14 pub segment_idx: u8,
15 pub _bitfield_align_1: [u8; 0],
16 pub _bitfield_1: BitField<[u8; 1usize]>,
17 pub capacity: u16,
18 pub reserved: u16,
19 pub flags: mi_page_flags_t,
20 pub _bitfield_align_2: [u8; 0],
21 pub _bitfield_2: BitField<[u8; 1usize]>,
22 pub free: *mut mi_block_t,
23 pub keys: [usize; 2usize],
24 pub used: u32,
25 pub xblock_size: u32,
26 pub local_free: *mut mi_block_t,
27 pub xthread_free: mi_thread_free_t,
28 pub xheap: usize,
29 pub next: *mut mi_page_t,
30 pub prev: *mut mi_page_t,
31}
32
33impl mi_page_t {
34 #[inline]
35 pub fn segment_in_use(&self) -> u8 {
36 self._bitfield_1.get(0usize, 1u8) as u8
37 }
38 #[inline]
39 pub fn set_segment_in_use(&mut self, val: u8) {
40 self._bitfield_1.set(0usize, 1u8, val as u64)
41 }
42 #[inline]
43 pub fn is_reset(&self) -> u8 {
44 self._bitfield_1.get(1usize, 1u8) as u8
45 }
46 #[inline]
47 pub fn set_is_reset(&mut self, val: u8) {
48 self._bitfield_1.set(1usize, 1u8, val as u64)
49 }
50 #[inline]
51 pub fn is_committed(&self) -> u8 {
52 self._bitfield_1.get(2usize, 1u8) as u8
53 }
54 #[inline]
55 pub fn set_is_committed(&mut self, val: u8) {
56 self._bitfield_1.set(2usize, 1u8, val as u64)
57 }
58 #[inline]
59 pub fn is_zero_init(&self) -> u8 {
60 self._bitfield_1.get(3usize, 1u8) as u8
61 }
62 #[inline]
63 pub fn set_is_zero_init(&mut self, val: u8) {
64 self._bitfield_1.set(3usize, 1u8, val as u64)
65 }
66 #[inline]
67 pub fn new_bitfield_1(
68 segment_in_use: u8,
69 is_reset: u8,
70 is_committed: u8,
71 is_zero_init: u8,
72 ) -> BitField<[u8; 1usize]> {
73 let mut _bitfield_unit: BitField<[u8; 1usize]> = Default::default();
74 _bitfield_unit.set(0usize, 1u8, segment_in_use as u64);
75 _bitfield_unit.set(1usize, 1u8, is_reset as u64);
76 _bitfield_unit.set(2usize, 1u8, is_committed as u64);
77 _bitfield_unit.set(3usize, 1u8, is_zero_init as u64);
78 _bitfield_unit
79 }
80 #[inline]
81 pub fn is_zero(&self) -> u8 {
82 self._bitfield_2.get(0usize, 1u8) as u8
83 }
84 #[inline]
85 pub fn set_is_zero(&mut self, val: u8) {
86 self._bitfield_2.set(0usize, 1u8, val as u64)
87 }
88 #[inline]
89 pub fn retire_expire(&self) -> u8 {
90 self._bitfield_2.get(1usize, 7u8) as u8
91 }
92 #[inline]
93 pub fn set_retire_expire(&mut self, val: u8) {
94 self._bitfield_2.set(1usize, 7u8, val as u64)
95 }
96 #[inline]
97 pub fn new_bitfield_2(is_zero: u8, retire_expire: u8) -> BitField<[u8; 1usize]> {
98 let mut _bitfield_unit: BitField<[u8; 1usize]> = Default::default();
99 _bitfield_unit.set(0usize, 1u8, is_zero as u64);
100 _bitfield_unit.set(1usize, 7u8, retire_expire as u64);
101 _bitfield_unit
102 }
103}
104
105#[repr(C)]
106#[derive(Debug, Copy, Clone)]
107pub struct mi_block_t {
108 pub next: usize,
109}
110pub type mi_delayed_t = cty::c_uint;
111pub const mi_delayed_t_MI_USE_DELAYED_FREE: mi_delayed_t = 0;
112pub const mi_delayed_t_MI_DELAYED_FREEING: mi_delayed_t = 1;
113pub const mi_delayed_t_MI_NO_DELAYED_FREE: mi_delayed_t = 2;
114pub const mi_delayed_t_MI_NEVER_DELAYED_FREE: mi_delayed_t = 3;
115
116#[repr(C)]
117#[derive(Copy, Clone)]
118pub union mi_page_flags_t {
119 pub full_aligned: u8,
120 pub x: mi_page_flags_t_ty_1,
121}
122
123#[repr(C, packed)]
124#[derive(Debug, Copy, Clone)]
125pub struct mi_page_flags_t_ty_1 {
126 pub _bitfield_align_1: [u8; 0],
127 pub _bitfield_1: BitField<[u8; 1usize]>,
128}
129impl mi_page_flags_t_ty_1 {
130 #[inline]
131 pub fn in_full(&self) -> u8 {
132 self._bitfield_1.get(0usize, 1u8) as u8
133 }
134 #[inline]
135 pub fn set_in_full(&mut self, val: u8) {
136 self._bitfield_1.set(0usize, 1u8, val as u64)
137 }
138 #[inline]
139 pub fn has_aligned(&self) -> u8 {
140 self._bitfield_1.get(1usize, 1u8) as u8
141 }
142 #[inline]
143 pub fn set_has_aligned(&mut self, val: u8) {
144 self._bitfield_1.set(1usize, 1u8, val as u64)
145 }
146 #[inline]
147 pub fn new_bitfield_1(in_full: u8, has_aligned: u8) -> BitField<[u8; 1usize]> {
148 let mut _bitfield_unit: BitField<[u8; 1usize]> = Default::default();
149 _bitfield_unit.set(0usize, 1u8, in_full as u64);
150 _bitfield_unit.set(1usize, 1u8, has_aligned as u64);
151 _bitfield_unit
152 }
153}
154
155#[repr(C)]
156#[derive(Copy, Clone)]
157pub struct mi_segment_t {
158 pub memid: usize,
159 pub mem_is_pinned: bool,
160 pub mem_is_committed: bool,
161 pub abandoned_next: *mut mi_segment_t,
163 pub next: *mut mi_segment_t,
164 pub prev: *mut mi_segment_t,
165 pub abandoned: usize,
166 pub abandoned_visits: usize,
167 pub used: usize,
168 pub capacity: usize,
169 pub segment_size: usize,
170 pub segment_info_size: usize,
171 pub cookie: usize,
172 pub page_shift: usize,
173 pub thread_id: usize,
174 pub page_kind: mi_page_kind_t,
175 pub pages: [mi_page_t; 1usize],
176}
177
178#[repr(C)]
179#[derive(Debug, Copy, Clone)]
180pub struct mi_page_queue_t {
181 pub first: *mut mi_page_t,
182 pub last: *mut mi_page_t,
183 pub block_size: usize,
184}
185
186#[repr(C)]
187#[derive(Debug, Copy, Clone)]
188pub struct mi_random_ctx_t {
189 pub input: [u32; 16usize],
190 pub output: [u32; 16usize],
191 pub output_available: cty::c_int,
192}
193
194#[repr(C)]
195#[derive(Debug, Copy, Clone)]
196pub struct mi_heap_t {
197 pub tld: *mut mi_tld_t,
198 pub pages_free_direct: [*mut mi_page_t; 130usize],
199 pub pages: [mi_page_queue_t; 75usize],
200 pub thread_delayed_free: mi_block_t,
201 pub thread_id: usize,
202 pub cookie: usize,
203 pub keys: [usize; 2usize],
204 pub random: mi_random_ctx_t,
205 pub page_count: usize,
206 pub page_retired_min: usize,
207 pub page_retired_max: usize,
208 pub next: *mut mi_heap_t,
209 pub no_reclaim: bool,
210}
211
212#[repr(C)]
213#[derive(Debug, Copy, Clone)]
214pub struct mi_stat_count_t {
215 pub allocated: i64,
216 pub freed: i64,
217 pub peak: i64,
218 pub current: i64,
219}
220
221#[repr(C)]
222#[derive(Debug, Copy, Clone)]
223pub struct mi_stat_counter_t {
224 pub total: i64,
225 pub count: i64,
226}
227
228#[repr(C)]
229#[derive(Debug, Copy, Clone)]
230pub struct mi_stats_t {
231 pub segments: mi_stat_count_t,
232 pub pages: mi_stat_count_t,
233 pub reserved: mi_stat_count_t,
234 pub committed: mi_stat_count_t,
235 pub reset: mi_stat_count_t,
236 pub page_committed: mi_stat_count_t,
237 pub segments_abandoned: mi_stat_count_t,
238 pub pages_abandoned: mi_stat_count_t,
239 pub threads: mi_stat_count_t,
240 pub normal: mi_stat_count_t,
241 pub huge: mi_stat_count_t,
242 pub giant: mi_stat_count_t,
243 pub malloc: mi_stat_count_t,
244 pub segments_cache: mi_stat_count_t,
245 pub pages_extended: mi_stat_counter_t,
246 pub mmap_calls: mi_stat_counter_t,
247 pub commit_calls: mi_stat_counter_t,
248 pub page_no_retire: mi_stat_counter_t,
249 pub searches: mi_stat_counter_t,
250 pub normal_count: mi_stat_counter_t,
251 pub huge_count: mi_stat_counter_t,
252 pub giant_count: mi_stat_counter_t,
253 pub normal_bins: [mi_stat_count_t; 74usize],
254}
255
256#[repr(C)]
257#[derive(Debug, Copy, Clone)]
258pub struct mi_segment_queue_t {
259 pub first: *mut mi_segment_t,
260 pub last: *mut mi_segment_t,
261}
262
263#[repr(C)]
264#[derive(Debug, Copy, Clone)]
265pub struct mi_os_tld_t {
266 pub region_idx: usize,
267 pub stats: *mut mi_stats_t,
268}
269
270#[repr(C)]
271#[derive(Debug, Copy, Clone)]
272pub struct mi_segments_tld_s {
273 pub small_free: mi_segment_queue_t,
274 pub medium_free: mi_segment_queue_t,
275 pub pages_reset: mi_page_queue_t,
276 pub count: usize,
277 pub peak_count: usize,
278 pub current_size: usize,
279 pub peak_size: usize,
280 pub cache_count: usize,
281 pub cache_size: usize,
282 pub cache: *mut mi_segment_t,
283 pub stats: *mut mi_stats_t,
284 pub os: *mut mi_os_tld_t,
285}
286pub type mi_segments_tld_t = mi_segments_tld_s;
287#[repr(C)]
288#[derive(Debug, Copy, Clone)]
289pub struct mi_tld_t {
290 pub heartbeat: cty::c_ulonglong,
291 pub recurse: bool,
292 pub heap_backing: *mut mi_heap_t,
293 pub heaps: *mut mi_heap_t,
294 pub segments: mi_segments_tld_t,
295 pub os: mi_os_tld_t,
296 pub stats: mi_stats_t,
297}