Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Use Relocatable instead of &MaybeRelocatable in load_data #860

Merged
merged 1 commit into from
Mar 1, 2023
Merged

Use Relocatable instead of &MaybeRelocatable in load_data #860

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
35 changes: 13 additions & 22 deletions src/hint_processor/builtin_hint_processor/blake2s_utils.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -43,16 +43,15 @@ Computes the blake2s compress function and fills the value in the right position
output_ptr should point to the middle of an instance, right after initial_state, message, t, f,
which should all have a value at this point, and right before the output portion which will be
written by this function.*/
fn compute_blake2s_func(vm: &mut VirtualMachine, output_rel: Relocatable) -> Result<(), HintError> {
let h = get_fixed_size_u32_array::<8>(&vm.get_integer_range(output_rel.sub_usize(26)?, 8)?)?;
fn compute_blake2s_func(vm: &mut VirtualMachine, output_ptr: Relocatable) -> Result<(), HintError> {
let h = get_fixed_size_u32_array::<8>(&vm.get_integer_range(output_ptr.sub_usize(26)?, 8)?)?;
let message =
get_fixed_size_u32_array::<16>(&vm.get_integer_range(output_rel.sub_usize(18)?, 16)?)?;
let t = felt_to_u32(vm.get_integer(output_rel.sub_usize(2)?)?.as_ref())?;
let f = felt_to_u32(vm.get_integer(output_rel.sub_usize(1)?)?.as_ref())?;
get_fixed_size_u32_array::<16>(&vm.get_integer_range(output_ptr.sub_usize(18)?, 16)?)?;
let t = felt_to_u32(vm.get_integer(output_ptr.sub_usize(2)?)?.as_ref())?;
let f = felt_to_u32(vm.get_integer(output_ptr.sub_usize(1)?)?.as_ref())?;
let new_state =
get_maybe_relocatable_array_from_u32(&blake2s_compress(&h, &message, t, 0, f, 0));
let output_ptr = MaybeRelocatable::RelocatableValue(output_rel);
vm.load_data(&output_ptr, &new_state)
vm.load_data(output_ptr, &new_state)
.map_err(HintError::Memory)?;
Ok(())
}
Expand Down Expand Up @@ -113,7 +112,7 @@ pub fn finalize_blake2s(
full_padding.extend_from_slice(padding);
}
let data = get_maybe_relocatable_array_from_u32(&full_padding);
vm.load_data(&MaybeRelocatable::RelocatableValue(blake2s_ptr_end), &data)
vm.load_data(blake2s_ptr_end, &data)
.map_err(HintError::Memory)?;
Ok(())
}
Expand Down Expand Up @@ -148,20 +147,16 @@ pub fn blake2s_add_uint256(
}
//Insert first batch of data
let data = get_maybe_relocatable_array_from_felt(&inner_data);
vm.load_data(&MaybeRelocatable::RelocatableValue(data_ptr), &data)
.map_err(HintError::Memory)?;
vm.load_data(data_ptr, &data).map_err(HintError::Memory)?;
//Build second batch of data
let mut inner_data = Vec::<Felt>::new();
for i in 0..4 {
inner_data.push((&high >> (B * i)) & &mask);
}
//Insert second batch of data
let data = get_maybe_relocatable_array_from_felt(&inner_data);
vm.load_data(
&MaybeRelocatable::RelocatableValue(data_ptr).add_usize(4),
&data,
)
.map_err(HintError::Memory)?;
vm.load_data(data_ptr + 4, &data)
.map_err(HintError::Memory)?;
Ok(())
}

Expand Down Expand Up @@ -195,20 +190,16 @@ pub fn blake2s_add_uint256_bigend(
}
//Insert first batch of data
let data = get_maybe_relocatable_array_from_felt(&inner_data);
vm.load_data(&MaybeRelocatable::RelocatableValue(data_ptr), &data)
.map_err(HintError::Memory)?;
vm.load_data(data_ptr, &data).map_err(HintError::Memory)?;
//Build second batch of data
let mut inner_data = Vec::<Felt>::new();
for i in 0..4 {
inner_data.push((&low >> (B * (3 - i))) & &mask);
}
//Insert second batch of data
let data = get_maybe_relocatable_array_from_felt(&inner_data);
vm.load_data(
&MaybeRelocatable::RelocatableValue(data_ptr).add_usize(4),
&data,
)
.map_err(HintError::Memory)?;
vm.load_data(data_ptr + 4, &data)
.map_err(HintError::Memory)?;
Ok(())
}

Expand Down
7 changes: 2 additions & 5 deletions src/vm/runners/cairo_runner.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -328,15 +328,12 @@ impl CairoRunner {
};
self.initial_pc = Some(initial_pc);
vm.segments
.load_data(
&MaybeRelocatable::RelocatableValue(prog_base),
&self.program.data,
)
.load_data(prog_base, &self.program.data)
.map_err(RunnerError::MemoryInitializationError)?;
}
if let Some(exec_base) = self.execution_base {
vm.segments
.load_data(&MaybeRelocatable::RelocatableValue(exec_base), &stack)
.load_data(exec_base, &stack)
.map_err(RunnerError::MemoryInitializationError)?;
} else {
return Err(RunnerError::NoProgBase);
Expand Down
6 changes: 3 additions & 3 deletions src/vm/vm_core.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -825,9 +825,9 @@ impl VirtualMachine {
///Writes data into the memory at address ptr and returns the first address after the data.
pub fn load_data(
&mut self,
ptr: &MaybeRelocatable,
ptr: Relocatable,
data: &Vec<MaybeRelocatable>,
) -> Result<MaybeRelocatable, MemoryError> {
) -> Result<Relocatable, MemoryError> {
self.segments.load_data(ptr, data)
}

Expand Down Expand Up @@ -4005,7 +4005,7 @@ mod tests {

let segment = vm.segments.add();
vm.load_data(
&segment.into(),
segment,
&vec![
mayberelocatable!(1),
mayberelocatable!(2),
Expand Down
40 changes: 17 additions & 23 deletions src/vm/vm_memory/memory_segments.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -56,13 +56,13 @@ impl MemorySegmentManager {
///Writes data into the memory at address ptr and returns the first address after the data.
pub fn load_data(
&mut self,
ptr: &MaybeRelocatable,
ptr: Relocatable,
data: &Vec<MaybeRelocatable>,
) -> Result<MaybeRelocatable, MemoryError> {
) -> Result<Relocatable, MemoryError> {
for (num, value) in data.iter().enumerate() {
self.memory.insert(&ptr.add_usize(num), value)?;
self.memory.insert(&(ptr + num), value)?;
}
Ok(ptr.add_usize(data.len()))
Ok(ptr + data.len())
}

pub fn new() -> MemorySegmentManager {
Expand Down Expand Up @@ -138,7 +138,7 @@ impl MemorySegmentManager {
CairoArg::Single(value) => Ok(value.clone()),
CairoArg::Array(values) => {
let base = self.add();
self.load_data(&base.into(), values)?;
self.load_data(base, values)?;
Ok(base.into())
}
CairoArg::Composed(cairo_args) => {
Expand All @@ -147,7 +147,7 @@ impl MemorySegmentManager {
.map(|cairo_arg| self.gen_cairo_arg(cairo_arg))
.collect::<Result<Vec<MaybeRelocatable>, VirtualMachineError>>()?;
let base = self.add();
self.load_data(&base.into(), &args)?;
self.load_data(base, &args)?;
Ok(base.into())
}
}
Expand All @@ -159,16 +159,10 @@ impl MemorySegmentManager {
arg: &dyn Any,
) -> Result<MaybeRelocatable, MemoryError> {
if let Some(vector) = arg.downcast_ref::<Vec<MaybeRelocatable>>() {
self.load_data(
&MaybeRelocatable::from((ptr.segment_index, ptr.offset)),
vector,
)
self.load_data(ptr, vector).map(Into::into)
} else if let Some(vector) = arg.downcast_ref::<Vec<Relocatable>>() {
let data = &vector.iter().map(|value| value.into()).collect();
self.load_data(
&MaybeRelocatable::from((ptr.segment_index, ptr.offset)),
data,
)
self.load_data(ptr, data).map(Into::into)
} else {
Err(MemoryError::WriteArg)
}
Expand Down Expand Up @@ -317,20 +311,20 @@ mod tests {
#[test]
fn load_data_empty() {
let data = Vec::new();
let ptr = MaybeRelocatable::from((0, 3));
let ptr = Relocatable::from((0, 3));
let mut segments = MemorySegmentManager::new();
let current_ptr = segments.load_data(&ptr, &data).unwrap();
assert_eq!(current_ptr, MaybeRelocatable::from((0, 3)));
let current_ptr = segments.load_data(ptr, &data).unwrap();
assert_eq!(current_ptr, Relocatable::from((0, 3)));
}

#[test]
fn load_data_one_element() {
let data = vec![MaybeRelocatable::from(Felt::new(4))];
let ptr = MaybeRelocatable::from((0, 0));
let ptr = Relocatable::from((0, 0));
let mut segments = MemorySegmentManager::new();
segments.add();
let current_ptr = segments.load_data(&ptr, &data).unwrap();
assert_eq!(current_ptr, MaybeRelocatable::from((0, 1)));
let current_ptr = segments.load_data(ptr, &data).unwrap();
assert_eq!(current_ptr, Relocatable::from((0, 1)));
assert_eq!(
segments.memory.get(&ptr).unwrap().as_ref(),
&MaybeRelocatable::from(Felt::new(4))
Expand All @@ -344,11 +338,11 @@ mod tests {
MaybeRelocatable::from(Felt::new(5)),
MaybeRelocatable::from(Felt::new(6)),
];
let ptr = MaybeRelocatable::from((0, 0));
let ptr = Relocatable::from((0, 0));
let mut segments = MemorySegmentManager::new();
segments.add();
let current_ptr = segments.load_data(&ptr, &data).unwrap();
assert_eq!(current_ptr, MaybeRelocatable::from((0, 3)));
let current_ptr = segments.load_data(ptr, &data).unwrap();
assert_eq!(current_ptr, Relocatable::from((0, 3)));

assert_eq!(
segments.memory.get(&ptr).unwrap().as_ref(),
Expand Down