Skip to content

Commit 655aa5d

Browse files
TomerStarkwareTomerStarkware
committed
arena for dict
1 parent eb0bf15 commit 655aa5d

16 files changed

Lines changed: 293 additions & 1055 deletions

File tree

‎debug_utils/cairo-native-stress/src/main.rs‎

Lines changed: 1 addition & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -312,12 +312,7 @@ where
312312
}
313313
};
314314

315-
let executor = AotNativeExecutor::new(
316-
shared_library,
317-
registry,
318-
metadata,
319-
native_module.metadata().get().cloned().unwrap_or_default(),
320-
);
315+
let executor = AotNativeExecutor::new(shared_library, registry, metadata);
321316
let executor = Arc::new(executor);
322317

323318
self.cache.insert(key, executor.clone());

‎src/arch.rs‎

Lines changed: 51 additions & 113 deletions
Original file line numberDiff line numberDiff line change
@@ -15,10 +15,7 @@ use cairo_lang_sierra::{
1515
ids::ConcreteTypeId,
1616
program_registry::ProgramRegistry,
1717
};
18-
use std::{
19-
ffi::c_void,
20-
ptr::{null, NonNull},
21-
};
18+
use std::ptr::{null, NonNull};
2219

2320
mod aarch64;
2421
mod x86_64;
@@ -27,11 +24,7 @@ mod x86_64;
2724
pub trait AbiArgument {
2825
/// Serialize the argument into the buffer. This method should keep track of arch-dependent
2926
/// stuff like register vs stack allocation.
30-
fn to_bytes(
31-
&self,
32-
buffer: &mut Vec<u8>,
33-
find_dict_drop_override: impl Copy + Fn(&ConcreteTypeId) -> Option<extern "C" fn(*mut c_void)>,
34-
) -> Result<()>;
27+
fn to_bytes(&self, buffer: &mut Vec<u8>) -> Result<()>;
3528
}
3629

3730
/// A wrapper that implements `AbiArgument` for `Value`s. It contains all the required stuff to
@@ -65,15 +58,10 @@ impl<'a> ValueWithInfoWrapper<'a> {
6558
}
6659

6760
impl AbiArgument for ValueWithInfoWrapper<'_> {
68-
fn to_bytes(
69-
&self,
70-
buffer: &mut Vec<u8>,
71-
find_dict_drop_override: impl Copy + Fn(&ConcreteTypeId) -> Option<extern "C" fn(*mut c_void)>,
72-
) -> Result<()> {
61+
fn to_bytes(&self, buffer: &mut Vec<u8>) -> Result<()> {
7362
match (self.value, self.info) {
7463
(value, CoreTypeConcrete::Box(info)) => {
75-
let ptr =
76-
value.to_ptr(self.arena, self.registry, &info.ty, find_dict_drop_override)?;
64+
let ptr = value.to_ptr(self.arena, self.registry, &info.ty)?;
7765

7866
let layout = self.registry.get_type(&info.ty)?.layout(self.registry)?;
7967
let heap_ptr = unsafe {
@@ -82,18 +70,13 @@ impl AbiArgument for ValueWithInfoWrapper<'_> {
8270
heap_ptr
8371
};
8472

85-
heap_ptr.to_bytes(buffer, find_dict_drop_override)?;
73+
heap_ptr.to_bytes(buffer)?;
8674
}
8775
(value, CoreTypeConcrete::Nullable(info)) => {
8876
if matches!(value, Value::Null) {
89-
null::<()>().to_bytes(buffer, find_dict_drop_override)?;
77+
null::<()>().to_bytes(buffer)?;
9078
} else {
91-
let ptr = value.to_ptr(
92-
self.arena,
93-
self.registry,
94-
self.type_id,
95-
find_dict_drop_override,
96-
)?;
79+
let ptr = value.to_ptr(self.arena, self.registry, self.type_id)?;
9780

9881
let layout = self.registry.get_type(&info.ty)?.layout(self.registry)?;
9982
let heap_ptr = unsafe {
@@ -102,63 +85,51 @@ impl AbiArgument for ValueWithInfoWrapper<'_> {
10285
heap_ptr
10386
};
10487

105-
heap_ptr.to_bytes(buffer, find_dict_drop_override)?;
88+
heap_ptr.to_bytes(buffer)?;
10689
}
10790
}
108-
(value, CoreTypeConcrete::NonZero(info) | CoreTypeConcrete::Snapshot(info)) => self
109-
.map(value, &info.ty)?
110-
.to_bytes(buffer, find_dict_drop_override)?,
91+
(value, CoreTypeConcrete::NonZero(info) | CoreTypeConcrete::Snapshot(info)) => {
92+
self.map(value, &info.ty)?.to_bytes(buffer)?
93+
}
11194

11295
(Value::Array(_), CoreTypeConcrete::Array(_)) => {
11396
// TODO: Assert that `info.ty` matches all the values' types. See: https://github.com/starkware-libs/cairo_native/issues/1216
11497

115-
let abi_ptr = self.value.to_ptr(
116-
self.arena,
117-
self.registry,
118-
self.type_id,
119-
find_dict_drop_override,
120-
)?;
98+
let abi_ptr = self.value.to_ptr(self.arena, self.registry, self.type_id)?;
12199
let abi = unsafe { abi_ptr.cast::<ArrayAbi<()>>().as_ref() };
122100

123-
abi.ptr.to_bytes(buffer, find_dict_drop_override)?;
124-
abi.since.to_bytes(buffer, find_dict_drop_override)?;
125-
abi.until.to_bytes(buffer, find_dict_drop_override)?;
126-
abi.capacity.to_bytes(buffer, find_dict_drop_override)?;
101+
abi.ptr.to_bytes(buffer)?;
102+
abi.since.to_bytes(buffer)?;
103+
abi.until.to_bytes(buffer)?;
104+
abi.capacity.to_bytes(buffer)?;
127105
}
128106
(Value::BoundedInt { .. }, CoreTypeConcrete::BoundedInt(_)) => {
129107
// See: https://github.com/starkware-libs/cairo_native/issues/1217
130108
native_panic!("todo: implement AbiArgument for Value::BoundedInt case")
131109
}
132-
(Value::Bytes31(value), CoreTypeConcrete::Bytes31(_)) => {
133-
value.to_bytes(buffer, find_dict_drop_override)?
134-
}
110+
(Value::Bytes31(value), CoreTypeConcrete::Bytes31(_)) => value.to_bytes(buffer)?,
135111
(Value::EcPoint(x, y), CoreTypeConcrete::EcPoint(_)) => {
136-
x.to_bytes(buffer, find_dict_drop_override)?;
137-
y.to_bytes(buffer, find_dict_drop_override)?;
112+
x.to_bytes(buffer)?;
113+
y.to_bytes(buffer)?;
138114
}
139115
(Value::EcState(x, y, x0, y0), CoreTypeConcrete::EcState(_)) => {
140-
x.to_bytes(buffer, find_dict_drop_override)?;
141-
y.to_bytes(buffer, find_dict_drop_override)?;
142-
x0.to_bytes(buffer, find_dict_drop_override)?;
143-
y0.to_bytes(buffer, find_dict_drop_override)?;
116+
x.to_bytes(buffer)?;
117+
y.to_bytes(buffer)?;
118+
x0.to_bytes(buffer)?;
119+
y0.to_bytes(buffer)?;
144120
}
145121
(Value::QM31(a, b, c, d), CoreTypeConcrete::QM31(_)) => {
146-
a.to_bytes(buffer, find_dict_drop_override)?;
147-
b.to_bytes(buffer, find_dict_drop_override)?;
148-
c.to_bytes(buffer, find_dict_drop_override)?;
149-
d.to_bytes(buffer, find_dict_drop_override)?;
122+
a.to_bytes(buffer)?;
123+
b.to_bytes(buffer)?;
124+
c.to_bytes(buffer)?;
125+
d.to_bytes(buffer)?;
150126
}
151127
(Value::Enum { tag, value, .. }, CoreTypeConcrete::Enum(info)) => {
152128
if self.info.is_memory_allocated(self.registry)? {
153-
let abi_ptr = self.value.to_ptr(
154-
self.arena,
155-
self.registry,
156-
self.type_id,
157-
find_dict_drop_override,
158-
)?;
129+
let abi_ptr = self.value.to_ptr(self.arena, self.registry, self.type_id)?;
159130

160131
let abi_ptr = unsafe { *abi_ptr.cast::<NonNull<()>>().as_ref() };
161-
abi_ptr.as_ptr().to_bytes(buffer, find_dict_drop_override)?;
132+
abi_ptr.as_ptr().to_bytes(buffer)?;
162133
} else {
163134
match info
164135
.variants
@@ -168,11 +139,10 @@ impl AbiArgument for ValueWithInfoWrapper<'_> {
168139
.div_ceil(8)
169140
{
170141
0 => {}
171-
_ => (*tag as u64).to_bytes(buffer, find_dict_drop_override)?,
142+
_ => (*tag as u64).to_bytes(buffer)?,
172143
}
173144

174-
self.map(value, &info.variants[*tag])?
175-
.to_bytes(buffer, find_dict_drop_override)?;
145+
self.map(value, &info.variants[*tag])?.to_bytes(buffer)?;
176146
}
177147
}
178148
(
@@ -184,19 +154,14 @@ impl AbiArgument for ValueWithInfoWrapper<'_> {
184154
| StarknetTypeConcrete::StorageAddress(_)
185155
| StarknetTypeConcrete::StorageBaseAddress(_),
186156
),
187-
) => value.to_bytes(buffer, find_dict_drop_override)?,
157+
) => value.to_bytes(buffer)?,
188158
(Value::Felt252Dict { .. }, CoreTypeConcrete::Felt252Dict(_)) => {
189159
// TODO: Assert that `info.ty` matches all the values' types.
190160

191161
self.value
192-
.to_ptr(
193-
self.arena,
194-
self.registry,
195-
self.type_id,
196-
find_dict_drop_override,
197-
)?
162+
.to_ptr(self.arena, self.registry, self.type_id)?
198163
.as_ptr()
199-
.to_bytes(buffer, find_dict_drop_override)?
164+
.to_bytes(buffer)?
200165
}
201166
(
202167
Value::Secp256K1Point(Secp256k1Point { x, y, is_infinity }),
@@ -210,61 +175,34 @@ impl AbiArgument for ValueWithInfoWrapper<'_> {
210175
Secp256PointTypeConcrete::R1(_),
211176
)),
212177
) => {
213-
x.to_bytes(buffer, find_dict_drop_override)?;
214-
y.to_bytes(buffer, find_dict_drop_override)?;
215-
is_infinity.to_bytes(buffer, find_dict_drop_override)?;
216-
}
217-
(Value::Sint128(value), CoreTypeConcrete::Sint128(_)) => {
218-
value.to_bytes(buffer, find_dict_drop_override)?
219-
}
220-
(Value::Sint16(value), CoreTypeConcrete::Sint16(_)) => {
221-
value.to_bytes(buffer, find_dict_drop_override)?
222-
}
223-
(Value::Sint32(value), CoreTypeConcrete::Sint32(_)) => {
224-
value.to_bytes(buffer, find_dict_drop_override)?
225-
}
226-
(Value::Sint64(value), CoreTypeConcrete::Sint64(_)) => {
227-
value.to_bytes(buffer, find_dict_drop_override)?
228-
}
229-
(Value::Sint8(value), CoreTypeConcrete::Sint8(_)) => {
230-
value.to_bytes(buffer, find_dict_drop_override)?
231-
}
178+
x.to_bytes(buffer)?;
179+
y.to_bytes(buffer)?;
180+
is_infinity.to_bytes(buffer)?;
181+
}
182+
(Value::Sint128(value), CoreTypeConcrete::Sint128(_)) => value.to_bytes(buffer)?,
183+
(Value::Sint16(value), CoreTypeConcrete::Sint16(_)) => value.to_bytes(buffer)?,
184+
(Value::Sint32(value), CoreTypeConcrete::Sint32(_)) => value.to_bytes(buffer)?,
185+
(Value::Sint64(value), CoreTypeConcrete::Sint64(_)) => value.to_bytes(buffer)?,
186+
(Value::Sint8(value), CoreTypeConcrete::Sint8(_)) => value.to_bytes(buffer)?,
232187
(Value::Struct { fields, .. }, CoreTypeConcrete::Struct(info)) => {
233188
if self.info.is_memory_allocated(self.registry)? {
234-
let abi_ptr = self.value.to_ptr(
235-
self.arena,
236-
self.registry,
237-
self.type_id,
238-
find_dict_drop_override,
239-
)?;
189+
let abi_ptr = self.value.to_ptr(self.arena, self.registry, self.type_id)?;
240190

241191
let abi_ptr = unsafe { *abi_ptr.cast::<NonNull<()>>().as_ref() };
242-
abi_ptr.as_ptr().to_bytes(buffer, find_dict_drop_override)?;
192+
abi_ptr.as_ptr().to_bytes(buffer)?;
243193
} else {
244194
fields
245195
.iter()
246196
.zip(&info.members)
247197
.map(|(value, type_id)| self.map(value, type_id))
248-
.try_for_each(|wrapper| {
249-
wrapper?.to_bytes(buffer, find_dict_drop_override)
250-
})?;
198+
.try_for_each(|wrapper| wrapper?.to_bytes(buffer))?;
251199
}
252200
}
253-
(Value::Uint128(value), CoreTypeConcrete::Uint128(_)) => {
254-
value.to_bytes(buffer, find_dict_drop_override)?
255-
}
256-
(Value::Uint16(value), CoreTypeConcrete::Uint16(_)) => {
257-
value.to_bytes(buffer, find_dict_drop_override)?
258-
}
259-
(Value::Uint32(value), CoreTypeConcrete::Uint32(_)) => {
260-
value.to_bytes(buffer, find_dict_drop_override)?
261-
}
262-
(Value::Uint64(value), CoreTypeConcrete::Uint64(_)) => {
263-
value.to_bytes(buffer, find_dict_drop_override)?
264-
}
265-
(Value::Uint8(value), CoreTypeConcrete::Uint8(_)) => {
266-
value.to_bytes(buffer, find_dict_drop_override)?
267-
}
201+
(Value::Uint128(value), CoreTypeConcrete::Uint128(_)) => value.to_bytes(buffer)?,
202+
(Value::Uint16(value), CoreTypeConcrete::Uint16(_)) => value.to_bytes(buffer)?,
203+
(Value::Uint32(value), CoreTypeConcrete::Uint32(_)) => value.to_bytes(buffer)?,
204+
(Value::Uint64(value), CoreTypeConcrete::Uint64(_)) => value.to_bytes(buffer)?,
205+
(Value::Uint8(value), CoreTypeConcrete::Uint8(_)) => value.to_bytes(buffer)?,
268206
// The catchall includes all unreachable combinations, as well
269207
// as some combination that may be reachable, and haven't been
270208
// encountered yet. Adding support for additional input arguments

0 commit comments

Comments
 (0)