fluencelabs/aquavm
1
0
Fork 0
mirror of https://github.com/fluencelabs/aquavm synced 2025-06-27 21:51:34 +00:00
Code Issues Projects Releases Wiki Activity

Introduce TracePos type for trace positions (#273)

Browse Source 
Many internal structures refer to trace positions; this is an important type of values. In the code, it is sometimes `u32`, sometimes `usize`. While such variables usually have "_pos" suffix, having a dedicated type does improve code with type guarantees.
This commit is contained in:
Ivan Boldyrev
2022-06-10 08:29:56 +03:00
committed by GitHub
parent e0f6fa1b4d
commit 6df2b9d084
47 changed files with 439 additions and 233 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
air/src/execution_step/air/call/call_result_setter.rs
View File

@ -20,6 +20,7 @@ use crate::execution_step::Generation;
use crate::execution_step::ValueAggregate;
use air_interpreter_data::CallResult;
use air_interpreter_data::TracePos;
use air_interpreter_data::Value;
use air_parser::ast::CallOutputValue;
use air_parser::ast::Variable;
@ -52,7 +53,7 @@ pub(crate) fn set_local_result<'i>(
pub(crate) fn set_result_from_value<'i>(
value: Value,
tetraplet: RcSecurityTetraplet,
trace_pos: usize,
trace_pos: TracePos,
output: &CallOutputValue<'i>,
exec_ctx: &mut ExecutionCtx<'i>,
) -> ExecutionResult<()> {

3
air/src/execution_step/air/call/prev_result_handler.rs
View File

@ -21,6 +21,7 @@ use crate::execution_step::RcSecurityTetraplet;
use air_interpreter_data::CallResult;
use air_interpreter_data::Sender;
use air_interpreter_data::TracePos;
use air_interpreter_interface::CallServiceResult;
use air_parser::ast::CallOutputValue;
use air_trace_handler::TraceHandler;
@ -40,7 +41,7 @@ pub(super) fn handle_prev_state<'i>(
tetraplet: &RcSecurityTetraplet,
output: &CallOutputValue<'i>,
prev_result: CallResult,
trace_pos: usize,
trace_pos: TracePos,
exec_ctx: &mut ExecutionCtx<'i>,
trace_ctx: &mut TraceHandler,
) -> ExecutionResult<StateDescriptor> {

9
air/src/execution_step/boxed_value/iterable.rs
View File

@ -27,6 +27,7 @@ use super::ValueAggregate;
use crate::execution_step::RcSecurityTetraplet;
use crate::JValue;
use air_interpreter_data::TracePos;
use std::rc::Rc;
/// This trait represent bidirectional iterator and
@ -56,13 +57,13 @@ pub(crate) trait Iterable<'ctx> {
/// through, i.e., it is the `iterable` in the `(fold collection iterable instruction)` statement.
#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) enum IterableItem<'ctx> {
RefRef((&'ctx JValue, &'ctx RcSecurityTetraplet, usize)),
RefValue((&'ctx JValue, RcSecurityTetraplet, usize)),
RcValue((Rc<JValue>, RcSecurityTetraplet, usize)),
RefRef((&'ctx JValue, &'ctx RcSecurityTetraplet, TracePos)),
RefValue((&'ctx JValue, RcSecurityTetraplet, TracePos)),
RcValue((Rc<JValue>, RcSecurityTetraplet, TracePos)),
}
impl IterableItem<'_> {
pub(crate) fn pos(&self) -> usize {
pub(crate) fn pos(&self) -> TracePos {
use IterableItem::*;
let pos = match self {

2
air/src/execution_step/boxed_value/iterable/json_path_result.rs
View File

@ -57,7 +57,7 @@ impl<'ctx> Iterable<'ctx> for IterableLambdaResult {
}
let jvalue = &self.jvalues[self.cursor];
let result = IterableItem::RefRef((jvalue, &self.tetraplet, 0));
let result = IterableItem::RefRef((jvalue, &self.tetraplet, 0.into()));
Some(result)
}

2
air/src/execution_step/boxed_value/iterable/vec_json_path_result.rs
View File

@ -59,7 +59,7 @@ impl<'ctx> Iterable<'ctx> for IterableVecJsonPathResult {
let jvalue = &self.jvalues[self.cursor];
let tetraplet = &self.tetraplets[self.cursor];
let result = IterableItem::RefRef((jvalue, tetraplet, 0));
let result = IterableItem::RefRef((jvalue, tetraplet, 0.into()));
Some(result)
}

5
air/src/execution_step/boxed_value/scalar.rs
View File

@ -19,6 +19,7 @@ use crate::execution_step::FoldState;
use crate::execution_step::RcSecurityTetraplet;
use crate::JValue;
use air_interpreter_data::TracePos;
use serde::Deserialize;
use serde::Serialize;
@ -30,7 +31,7 @@ use std::rc::Rc;
pub struct ValueAggregate {
pub result: Rc<JValue>,
pub tetraplet: RcSecurityTetraplet,
pub trace_pos: usize,
pub trace_pos: TracePos,
}
pub(crate) enum ScalarRef<'i> {
@ -51,7 +52,7 @@ impl<'i> ScalarRef<'i> {
}
impl ValueAggregate {
pub(crate) fn new(result: Rc<JValue>, tetraplet: RcSecurityTetraplet, trace_pos: usize) -> Self {
pub(crate) fn new(result: Rc<JValue>, tetraplet: RcSecurityTetraplet, trace_pos: TracePos) -> Self {
Self {
result,
tetraplet,

4
air/src/execution_step/boxed_value/stream.rs
View File

@ -243,8 +243,8 @@ mod test {
#[test]
fn test_slice_iter() {
let value_1 = ValueAggregate::new(Rc::new(json!("value")), <_>::default(), 1);
let value_2 = ValueAggregate::new(Rc::new(json!("value")), <_>::default(), 1);
let value_1 = ValueAggregate::new(Rc::new(json!("value")), <_>::default(), 1.into());
let value_2 = ValueAggregate::new(Rc::new(json!("value")), <_>::default(), 1.into());
let mut stream = Stream::from_generations_count(2);
stream.add_value(value_1, Generation::Nth(0)).unwrap();

2
air/src/execution_step/execution_context/scalar_variables.rs
View File

@ -386,7 +386,7 @@ mod test {
let rc_tetraplet = Rc::new(tetraplet);
let value = json!(1u64);
let rc_value = Rc::new(value);
let value_aggregate = ValueAggregate::new(rc_value, rc_tetraplet, 1);
let value_aggregate = ValueAggregate::new(rc_value, rc_tetraplet, 1.into());
let value_1_name = "name_1";
scalars.set_value(value_1_name, value_aggregate.clone()).unwrap();

2
air/tests/test_module/features/data_merging/data_merge.rs
View File

@ -300,7 +300,7 @@ fn fold_merge() {
if let ExecutedState::Fold(fold) = state {
for subtrace_lore in fold.lore.iter() {
let value_pos = subtrace_lore.value_pos as usize;
let value_pos = subtrace_lore.value_pos;
if let ExecutedState::Call(CallResult::Executed(value)) = &data.trace[value_pos] {
let value = match value {
Value::Scalar(value) => value,

2
air/tests/test_module/features/errors/last_error.rs
View File

@ -211,7 +211,7 @@ fn variable_names_shown_in_error() {
let trace = trace_from_result(&result);
assert_eq!(
trace[1],
trace[1.into()],
executed_state::scalar(json!(
"expected JValue type 'string' for the variable `-relay-`, but got '1'"
))

15
air/tests/test_module/features/lambda/lambda.rs
View File

@ -71,7 +71,7 @@ fn lambda_with_string_scalar() {
let result = checked_call_vm!(local_vm, <_>::default(), script, "", result.data);
let trace = trace_from_result(&result);
assert_eq!(&trace[2], &executed_state::scalar_number(1u32));
assert_eq!(&trace[2.into()], &executed_state::scalar_number(1u32));
}
#[test]
@ -103,7 +103,7 @@ fn lambda_with_number_scalar() {
let result = checked_call_vm!(local_vm, <_>::default(), script, "", result.data);
let trace = trace_from_result(&result);
assert_eq!(&trace[2], &executed_state::scalar_number(1u32));
assert_eq!(&trace[2.into()], &executed_state::scalar_number(1u32));
}
#[test]
@ -143,7 +143,7 @@ fn lambda_with_number_stream() {
let result = checked_call_vm!(local_vm, <_>::default(), script, "", result.data);
let actual_trace = trace_from_result(&result);
assert_eq!(&actual_trace[5], &executed_state::scalar_number(2));
assert_eq!(&actual_trace[5.into()], &executed_state::scalar_number(2));
}
#[test]
@ -188,7 +188,7 @@ fn lambda_with_number_stream_and_followed_scalar() {
let result = checked_call_vm!(local_vm, <_>::default(), script, "", result.data);
let actual_trace = trace_from_result(&result);
assert_eq!(&actual_trace[6], &executed_state::scalar_number(checkable_value));
assert_eq!(&actual_trace[6.into()], &executed_state::scalar_number(checkable_value));
}
#[test]
@ -220,7 +220,7 @@ fn lambda_with_scalar_join() {
let result = checked_call_vm!(local_vm, <_>::default(), script, "", result.data);
let trace = trace_from_result(&result);
assert_eq!(&trace[3], &executed_state::request_sent_by("set_variable"));
assert_eq!(&trace[3.into()], &executed_state::request_sent_by("set_variable"));
}
#[test]
@ -260,5 +260,8 @@ fn lambda_with_stream_join() {
let result = checked_call_vm!(local_vm, <_>::default(), script, "", result.data);
let actual_trace = trace_from_result(&result);
assert_eq!(&actual_trace[6], &executed_state::request_sent_by("set_variable"));
assert_eq!(
&actual_trace[6.into()],
&executed_state::request_sent_by("set_variable")
);
}

48
air/tests/test_module/features/streams/recursive_streams.rs
View File

@ -58,8 +58,8 @@ fn recursive_stream_with_early_exit() {
executed_state::stream_number(1, 0),
executed_state::stream_number(1, 1),
executed_state::fold(vec![
executed_state::subtrace_lore(0, SubTraceDesc::new(3, 1), SubTraceDesc::new(4, 0)),
executed_state::subtrace_lore(1, SubTraceDesc::new(4, 1), SubTraceDesc::new(5, 0)),
executed_state::subtrace_lore(0, subtrace_desc(3, 1), subtrace_desc(4, 0)),
executed_state::subtrace_lore(1, subtrace_desc(4, 1), subtrace_desc(5, 0)),
]),
executed_state::scalar_string("stop"),
executed_state::scalar_string("stop"),
@ -120,27 +120,27 @@ fn recursive_stream_many_iterations() {
let result = checked_call_vm!(vm_1, <_>::default(), &script, "", "");
let actual_trace = trace_from_result(&result);
let actual_fold = &actual_trace[2];
let actual_fold = &actual_trace[2.into()];
let expected_fold = executed_state::fold(vec![
executed_state::subtrace_lore(0, SubTraceDesc::new(3, 2), SubTraceDesc::new(5, 0)),
executed_state::subtrace_lore(1, SubTraceDesc::new(5, 2), SubTraceDesc::new(7, 0)),
executed_state::subtrace_lore(4, SubTraceDesc::new(7, 2), SubTraceDesc::new(9, 0)),
executed_state::subtrace_lore(6, SubTraceDesc::new(9, 2), SubTraceDesc::new(11, 0)),
executed_state::subtrace_lore(8, SubTraceDesc::new(11, 2), SubTraceDesc::new(15, 0)),
executed_state::subtrace_lore(10, SubTraceDesc::new(13, 2), SubTraceDesc::new(15, 0)),
executed_state::subtrace_lore(12, SubTraceDesc::new(15, 2), SubTraceDesc::new(19, 0)),
executed_state::subtrace_lore(14, SubTraceDesc::new(17, 2), SubTraceDesc::new(19, 0)),
executed_state::subtrace_lore(16, SubTraceDesc::new(19, 1), SubTraceDesc::new(20, 0)),
executed_state::subtrace_lore(0, subtrace_desc(3, 2), subtrace_desc(5, 0)),
executed_state::subtrace_lore(1, subtrace_desc(5, 2), subtrace_desc(7, 0)),
executed_state::subtrace_lore(4, subtrace_desc(7, 2), subtrace_desc(9, 0)),
executed_state::subtrace_lore(6, subtrace_desc(9, 2), subtrace_desc(11, 0)),
executed_state::subtrace_lore(8, subtrace_desc(11, 2), subtrace_desc(15, 0)),
executed_state::subtrace_lore(10, subtrace_desc(13, 2), subtrace_desc(15, 0)),
executed_state::subtrace_lore(12, subtrace_desc(15, 2), subtrace_desc(19, 0)),
executed_state::subtrace_lore(14, subtrace_desc(17, 2), subtrace_desc(19, 0)),
executed_state::subtrace_lore(16, subtrace_desc(19, 1), subtrace_desc(20, 0)),
]);
assert_eq!(actual_fold, &expected_fold);
let actual_last_state = &actual_trace[20];
let actual_last_state = &actual_trace[20.into()];
let expected_last_state = executed_state::request_sent_by(vm_peer_id_1);
assert_eq!(actual_last_state, &expected_last_state);
let result = checked_call_vm!(vm_2, <_>::default(), script, "", result.data);
let actual_trace = trace_from_result(&result);
let actual_last_state = &actual_trace[20];
let actual_last_state = &actual_trace[20.into()];
let expected_last_state = executed_state::scalar_string(result_value);
assert_eq!(actual_last_state, &expected_last_state);
}
@ -206,11 +206,11 @@ fn recursive_stream_join() {
executed_state::stream_string("non_join", 0),
executed_state::scalar_string(""),
executed_state::fold(vec![
executed_state::subtrace_lore(1, SubTraceDesc::new(4, 2), SubTraceDesc::new(6, 0)),
executed_state::subtrace_lore(5, SubTraceDesc::new(6, 2), SubTraceDesc::new(8, 0)),
executed_state::subtrace_lore(7, SubTraceDesc::new(8, 2), SubTraceDesc::new(10, 0)),
executed_state::subtrace_lore(9, SubTraceDesc::new(10, 2), SubTraceDesc::new(12, 0)),
executed_state::subtrace_lore(11, SubTraceDesc::new(12, 2), SubTraceDesc::new(14, 0)),
executed_state::subtrace_lore(1, subtrace_desc(4, 2), subtrace_desc(6, 0)),
executed_state::subtrace_lore(5, subtrace_desc(6, 2), subtrace_desc(8, 0)),
executed_state::subtrace_lore(7, subtrace_desc(8, 2), subtrace_desc(10, 0)),
executed_state::subtrace_lore(9, subtrace_desc(10, 2), subtrace_desc(12, 0)),
executed_state::subtrace_lore(11, subtrace_desc(12, 2), subtrace_desc(14, 0)),
]),
executed_state::scalar_string("non_join"),
executed_state::ap(Some(1)),
@ -280,7 +280,7 @@ fn recursive_stream_error_handling() {
let result = checked_call_vm!(vm_1, <_>::default(), &script, "", "");
let result = checked_call_vm!(vm_2, <_>::default(), &script, "", result.data);
let actual_trace = trace_from_result(&result);
let actual_last_state = &actual_trace[10];
let actual_last_state = &actual_trace[10.into()];
let expected_last_state = executed_state::scalar_string(result_value);
assert_eq!(actual_last_state, &expected_last_state);
@ -356,12 +356,12 @@ fn recursive_stream_inner_fold() {
let result = checked_call_vm!(vm_2, <_>::default(), script, "", result.data);
let actual_trace = trace_from_result(&result);
let actual_last_state = &actual_trace[22];
let actual_last_state = &actual_trace[22.into()];
let expected_last_state = executed_state::scalar_string(result_value);
assert_eq!(actual_last_state, &expected_last_state);
let external_fold = &actual_trace[2];
let internal_fold = &actual_trace[5];
let external_fold = &actual_trace[2.into()];
let internal_fold = &actual_trace[5.into()];
let actual_fold_lores_count = match (external_fold, internal_fold) {
(ExecutedState::Fold(external_fold), ExecutedState::Fold(internal_fold)) => {
external_fold.lore.len() + internal_fold.lore.len()
@ -438,7 +438,7 @@ fn recursive_stream_fold_with_n_service_call() {
let test_params = TestRunParameters::from_init_peer_id(vm_peer_id);
let result = checked_call_vm!(vm, test_params, &script, "", "");
let actual_trace = trace_from_result(&result);
let actual_fold_state = match &actual_trace[2] {
let actual_fold_state = match &actual_trace[2.into()] {
ExecutedState::Fold(fold_result) => fold_result,
_ => panic!("2nd state should be fold"),
};

90
air/tests/test_module/features/streams/streams.rs
View File

@ -85,9 +85,9 @@ fn stream_merging_v0() {
executed_state::stream_string("1", 0),
executed_state::request_sent_by(initiator_id),
executed_state::fold(vec![
executed_state::subtrace_lore(7, SubTraceDesc::new(15, 2), SubTraceDesc::new(21, 0)),
executed_state::subtrace_lore(9, SubTraceDesc::new(17, 2), SubTraceDesc::new(21, 0)),
executed_state::subtrace_lore(12, SubTraceDesc::new(19, 2), SubTraceDesc::new(21, 0)),
executed_state::subtrace_lore(7, subtrace_desc(15, 2), subtrace_desc(21, 0)),
executed_state::subtrace_lore(9, subtrace_desc(17, 2), subtrace_desc(21, 0)),
executed_state::subtrace_lore(12, subtrace_desc(19, 2), subtrace_desc(21, 0)),
]),
executed_state::scalar_string(unit_call_service_result),
executed_state::scalar_string(unit_call_service_result),
@ -123,11 +123,11 @@ fn stream_merging_v0() {
executed_state::stream_string("1", 0),
executed_state::stream_string("2", 1),
executed_state::fold(vec![
executed_state::subtrace_lore(7, SubTraceDesc::new(15, 2), SubTraceDesc::new(21, 0)),
executed_state::subtrace_lore(9, SubTraceDesc::new(17, 2), SubTraceDesc::new(21, 0)),
executed_state::subtrace_lore(12, SubTraceDesc::new(19, 2), SubTraceDesc::new(21, 0)),
executed_state::subtrace_lore(8, SubTraceDesc::new(21, 2), SubTraceDesc::new(25, 0)),
executed_state::subtrace_lore(13, SubTraceDesc::new(23, 2), SubTraceDesc::new(25, 0)),
executed_state::subtrace_lore(7, subtrace_desc(15, 2), subtrace_desc(21, 0)),
executed_state::subtrace_lore(9, subtrace_desc(17, 2), subtrace_desc(21, 0)),
executed_state::subtrace_lore(12, subtrace_desc(19, 2), subtrace_desc(21, 0)),
executed_state::subtrace_lore(8, subtrace_desc(21, 2), subtrace_desc(25, 0)),
executed_state::subtrace_lore(13, subtrace_desc(23, 2), subtrace_desc(25, 0)),
]),
executed_state::scalar_string(unit_call_service_result),
executed_state::scalar_string(unit_call_service_result),
@ -167,13 +167,13 @@ fn stream_merging_v0() {
executed_state::stream_string("1", 0),
executed_state::stream_string("2", 1),
executed_state::fold(vec![
executed_state::subtrace_lore(7, SubTraceDesc::new(15, 2), SubTraceDesc::new(21, 0)),
executed_state::subtrace_lore(9, SubTraceDesc::new(17, 2), SubTraceDesc::new(21, 0)),
executed_state::subtrace_lore(12, SubTraceDesc::new(19, 2), SubTraceDesc::new(21, 0)),
executed_state::subtrace_lore(8, SubTraceDesc::new(21, 2), SubTraceDesc::new(25, 0)),
executed_state::subtrace_lore(13, SubTraceDesc::new(23, 2), SubTraceDesc::new(25, 0)),
executed_state::subtrace_lore(10, SubTraceDesc::new(25, 2), SubTraceDesc::new(29, 0)),
executed_state::subtrace_lore(11, SubTraceDesc::new(27, 2), SubTraceDesc::new(29, 0)),
executed_state::subtrace_lore(7, subtrace_desc(15, 2), subtrace_desc(21, 0)),
executed_state::subtrace_lore(9, subtrace_desc(17, 2), subtrace_desc(21, 0)),
executed_state::subtrace_lore(12, subtrace_desc(19, 2), subtrace_desc(21, 0)),
executed_state::subtrace_lore(8, subtrace_desc(21, 2), subtrace_desc(25, 0)),
executed_state::subtrace_lore(13, subtrace_desc(23, 2), subtrace_desc(25, 0)),
executed_state::subtrace_lore(10, subtrace_desc(25, 2), subtrace_desc(29, 0)),
executed_state::subtrace_lore(11, subtrace_desc(27, 2), subtrace_desc(29, 0)),
]),
executed_state::scalar_string(unit_call_service_result),
executed_state::scalar_string(unit_call_service_result),
@ -237,9 +237,9 @@ fn stream_merging_v1() {
executed_state::stream_string("1", 0),
executed_state::request_sent_by(initiator_id),
executed_state::fold(vec![
executed_state::subtrace_lore(7, SubTraceDesc::new(15, 1), SubTraceDesc::new(20, 1)),
executed_state::subtrace_lore(9, SubTraceDesc::new(16, 1), SubTraceDesc::new(19, 1)),
executed_state::subtrace_lore(12, SubTraceDesc::new(17, 1), SubTraceDesc::new(18, 1)),
executed_state::subtrace_lore(7, subtrace_desc(15, 1), subtrace_desc(20, 1)),
executed_state::subtrace_lore(9, subtrace_desc(16, 1), subtrace_desc(19, 1)),
executed_state::subtrace_lore(12, subtrace_desc(17, 1), subtrace_desc(18, 1)),
]),
executed_state::scalar_string(unit_call_service_result),
executed_state::scalar_string(unit_call_service_result),
@ -275,11 +275,11 @@ fn stream_merging_v1() {
executed_state::stream_string("1", 0),
executed_state::stream_string("2", 1),
executed_state::fold(vec![
executed_state::subtrace_lore(7, SubTraceDesc::new(15, 1), SubTraceDesc::new(20, 1)),
executed_state::subtrace_lore(9, SubTraceDesc::new(16, 1), SubTraceDesc::new(19, 1)),
executed_state::subtrace_lore(12, SubTraceDesc::new(17, 1), SubTraceDesc::new(18, 1)),
executed_state::subtrace_lore(8, SubTraceDesc::new(21, 1), SubTraceDesc::new(24, 1)),
executed_state::subtrace_lore(13, SubTraceDesc::new(22, 1), SubTraceDesc::new(23, 1)),
executed_state::subtrace_lore(7, subtrace_desc(15, 1), subtrace_desc(20, 1)),
executed_state::subtrace_lore(9, subtrace_desc(16, 1), subtrace_desc(19, 1)),
executed_state::subtrace_lore(12, subtrace_desc(17, 1), subtrace_desc(18, 1)),
executed_state::subtrace_lore(8, subtrace_desc(21, 1), subtrace_desc(24, 1)),
executed_state::subtrace_lore(13, subtrace_desc(22, 1), subtrace_desc(23, 1)),
]),
executed_state::scalar_string(unit_call_service_result),
executed_state::scalar_string(unit_call_service_result),
@ -319,13 +319,13 @@ fn stream_merging_v1() {
executed_state::stream_string("1", 0),
executed_state::stream_string("2", 1),
executed_state::fold(vec![
executed_state::subtrace_lore(7, SubTraceDesc::new(15, 1), SubTraceDesc::new(20, 1)),
executed_state::subtrace_lore(9, SubTraceDesc::new(16, 1), SubTraceDesc::new(19, 1)),
executed_state::subtrace_lore(12, SubTraceDesc::new(17, 1), SubTraceDesc::new(18, 1)),
executed_state::subtrace_lore(8, SubTraceDesc::new(21, 1), SubTraceDesc::new(24, 1)),
executed_state::subtrace_lore(13, SubTraceDesc::new(22, 1), SubTraceDesc::new(23, 1)),
executed_state::subtrace_lore(10, SubTraceDesc::new(25, 1), SubTraceDesc::new(28, 1)),
executed_state::subtrace_lore(11, SubTraceDesc::new(26, 1), SubTraceDesc::new(27, 1)),
executed_state::subtrace_lore(7, subtrace_desc(15, 1), subtrace_desc(20, 1)),
executed_state::subtrace_lore(9, subtrace_desc(16, 1), subtrace_desc(19, 1)),
executed_state::subtrace_lore(12, subtrace_desc(17, 1), subtrace_desc(18, 1)),
executed_state::subtrace_lore(8, subtrace_desc(21, 1), subtrace_desc(24, 1)),
executed_state::subtrace_lore(13, subtrace_desc(22, 1), subtrace_desc(23, 1)),
executed_state::subtrace_lore(10, subtrace_desc(25, 1), subtrace_desc(28, 1)),
executed_state::subtrace_lore(11, subtrace_desc(26, 1), subtrace_desc(27, 1)),
]),
executed_state::scalar_string(unit_call_service_result),
executed_state::scalar_string(unit_call_service_result),
@ -389,9 +389,9 @@ fn stream_merging_v2() {
executed_state::stream_string("1", 0),
executed_state::request_sent_by(initiator_id),
executed_state::fold(vec![
executed_state::subtrace_lore(7, SubTraceDesc::new(15, 0), SubTraceDesc::new(19, 2)),
executed_state::subtrace_lore(9, SubTraceDesc::new(15, 0), SubTraceDesc::new(17, 2)),
executed_state::subtrace_lore(12, SubTraceDesc::new(15, 0), SubTraceDesc::new(15, 2)),
executed_state::subtrace_lore(7, subtrace_desc(15, 0), subtrace_desc(19, 2)),
executed_state::subtrace_lore(9, subtrace_desc(15, 0), subtrace_desc(17, 2)),
executed_state::subtrace_lore(12, subtrace_desc(15, 0), subtrace_desc(15, 2)),
]),
executed_state::scalar_string(unit_call_service_result),
executed_state::scalar_string(unit_call_service_result),
@ -427,11 +427,11 @@ fn stream_merging_v2() {
executed_state::stream_string("1", 0),
executed_state::stream_string("2", 1),
executed_state::fold(vec![
executed_state::subtrace_lore(7, SubTraceDesc::new(15, 0), SubTraceDesc::new(19, 2)),
executed_state::subtrace_lore(9, SubTraceDesc::new(15, 0), SubTraceDesc::new(17, 2)),
executed_state::subtrace_lore(12, SubTraceDesc::new(15, 0), SubTraceDesc::new(15, 2)),
executed_state::subtrace_lore(8, SubTraceDesc::new(21, 0), SubTraceDesc::new(23, 2)),
executed_state::subtrace_lore(13, SubTraceDesc::new(21, 0), SubTraceDesc::new(21, 2)),
executed_state::subtrace_lore(7, subtrace_desc(15, 0), subtrace_desc(19, 2)),
executed_state::subtrace_lore(9, subtrace_desc(15, 0), subtrace_desc(17, 2)),
executed_state::subtrace_lore(12, subtrace_desc(15, 0), subtrace_desc(15, 2)),
executed_state::subtrace_lore(8, subtrace_desc(21, 0), subtrace_desc(23, 2)),
executed_state::subtrace_lore(13, subtrace_desc(21, 0), subtrace_desc(21, 2)),
]),
executed_state::scalar_string(unit_call_service_result),
executed_state::scalar_string(unit_call_service_result),
@ -471,13 +471,13 @@ fn stream_merging_v2() {
executed_state::stream_string("1", 0),
executed_state::stream_string("2", 1),
executed_state::fold(vec![
executed_state::subtrace_lore(7, SubTraceDesc::new(15, 0), SubTraceDesc::new(19, 2)),
executed_state::subtrace_lore(9, SubTraceDesc::new(15, 0), SubTraceDesc::new(17, 2)),
executed_state::subtrace_lore(12, SubTraceDesc::new(15, 0), SubTraceDesc::new(15, 2)),
executed_state::subtrace_lore(8, SubTraceDesc::new(21, 0), SubTraceDesc::new(23, 2)),
executed_state::subtrace_lore(13, SubTraceDesc::new(21, 0), SubTraceDesc::new(21, 2)),
executed_state::subtrace_lore(10, SubTraceDesc::new(25, 0), SubTraceDesc::new(27, 2)),
executed_state::subtrace_lore(11, SubTraceDesc::new(25, 0), SubTraceDesc::new(25, 2)),
executed_state::subtrace_lore(7, subtrace_desc(15, 0), subtrace_desc(19, 2)),
executed_state::subtrace_lore(9, subtrace_desc(15, 0), subtrace_desc(17, 2)),
executed_state::subtrace_lore(12, subtrace_desc(15, 0), subtrace_desc(15, 2)),
executed_state::subtrace_lore(8, subtrace_desc(21, 0), subtrace_desc(23, 2)),
executed_state::subtrace_lore(13, subtrace_desc(21, 0), subtrace_desc(21, 2)),
executed_state::subtrace_lore(10, subtrace_desc(25, 0), subtrace_desc(27, 2)),
executed_state::subtrace_lore(11, subtrace_desc(25, 0), subtrace_desc(25, 2)),
]),
executed_state::scalar_string(unit_call_service_result),
executed_state::scalar_string(unit_call_service_result),

46
air/tests/test_module/features/streams/streams_early_exit.rs
View File

@ -244,27 +244,27 @@ fn fold_early_exit() {
executed_state::par(11, 1),
executed_state::fold(vec![executed_state::subtrace_lore(
4,
SubTraceDesc::new(14, 9),
SubTraceDesc::new(23, 0),
subtrace_desc(14, 9),
subtrace_desc(23, 0),
)]),
executed_state::fold(vec![executed_state::subtrace_lore(
6,
SubTraceDesc::new(15, 8),
SubTraceDesc::new(23, 0),
subtrace_desc(15, 8),
subtrace_desc(23, 0),
)]),
executed_state::fold(vec![
executed_state::subtrace_lore(8, SubTraceDesc::new(16, 3), SubTraceDesc::new(22, 0)),
executed_state::subtrace_lore(9, SubTraceDesc::new(19, 3), SubTraceDesc::new(22, 0)),
executed_state::subtrace_lore(8, subtrace_desc(16, 3), subtrace_desc(22, 0)),
executed_state::subtrace_lore(9, subtrace_desc(19, 3), subtrace_desc(22, 0)),
]),
executed_state::fold(vec![
executed_state::subtrace_lore(10, SubTraceDesc::new(17, 1), SubTraceDesc::new(19, 0)),
executed_state::subtrace_lore(11, SubTraceDesc::new(18, 1), SubTraceDesc::new(19, 0)),
executed_state::subtrace_lore(10, subtrace_desc(17, 1), subtrace_desc(19, 0)),
executed_state::subtrace_lore(11, subtrace_desc(18, 1), subtrace_desc(19, 0)),
]),
executed_state::scalar_string(unit_call_service_result),
executed_state::scalar_string(unit_call_service_result),
executed_state::fold(vec![
executed_state::subtrace_lore(10, SubTraceDesc::new(20, 1), SubTraceDesc::new(22, 0)),
executed_state::subtrace_lore(11, SubTraceDesc::new(21, 1), SubTraceDesc::new(22, 0)),
executed_state::subtrace_lore(10, subtrace_desc(20, 1), subtrace_desc(22, 0)),
executed_state::subtrace_lore(11, subtrace_desc(21, 1), subtrace_desc(22, 0)),
]),
executed_state::scalar_string(unit_call_service_result),
executed_state::scalar_string(unit_call_service_result),
@ -353,24 +353,24 @@ fn fold_par_early_exit() {
executed_state::stream_string("d2", 0),
executed_state::par(69, 1),
executed_state::fold(vec![
executed_state::subtrace_lore(4, SubTraceDesc::new(14, 34), SubTraceDesc::new(82, 0)),
executed_state::subtrace_lore(5, SubTraceDesc::new(48, 34), SubTraceDesc::new(82, 0)),
executed_state::subtrace_lore(4, subtrace_desc(14, 34), subtrace_desc(82, 0)),
executed_state::subtrace_lore(5, subtrace_desc(48, 34), subtrace_desc(82, 0)),
]),
executed_state::par(33, 34),
executed_state::fold(vec![
executed_state::subtrace_lore(6, SubTraceDesc::new(16, 16), SubTraceDesc::new(48, 0)),
executed_state::subtrace_lore(7, SubTraceDesc::new(32, 16), SubTraceDesc::new(48, 0)),
executed_state::subtrace_lore(6, subtrace_desc(16, 16), subtrace_desc(48, 0)),
executed_state::subtrace_lore(7, subtrace_desc(32, 16), subtrace_desc(48, 0)),
]),
executed_state::par(15, 16),
executed_state::par(13, 1),
executed_state::fold(vec![
executed_state::subtrace_lore(8, SubTraceDesc::new(19, 6), SubTraceDesc::new(31, 0)),
executed_state::subtrace_lore(9, SubTraceDesc::new(25, 6), SubTraceDesc::new(31, 0)),
executed_state::subtrace_lore(8, subtrace_desc(19, 6), subtrace_desc(31, 0)),
executed_state::subtrace_lore(9, subtrace_desc(25, 6), subtrace_desc(31, 0)),
]),
executed_state::par(5, 6),
executed_state::fold(vec![
executed_state::subtrace_lore(10, SubTraceDesc::new(21, 2), SubTraceDesc::new(25, 0)),
executed_state::subtrace_lore(11, SubTraceDesc::new(23, 2), SubTraceDesc::new(25, 0)),
executed_state::subtrace_lore(10, subtrace_desc(21, 2), subtrace_desc(25, 0)),
executed_state::subtrace_lore(11, subtrace_desc(23, 2), subtrace_desc(25, 0)),
]),
executed_state::par(1, 2),
executed_state::scalar_string(unit_call_service_result),
@ -378,8 +378,8 @@ fn fold_par_early_exit() {
executed_state::scalar_string(unit_call_service_result),
executed_state::par(5, 0),
executed_state::fold(vec![
executed_state::subtrace_lore(10, SubTraceDesc::new(27, 2), SubTraceDesc::new(31, 0)),
executed_state::subtrace_lore(11, SubTraceDesc::new(29, 2), SubTraceDesc::new(31, 0)),
executed_state::subtrace_lore(10, subtrace_desc(27, 2), subtrace_desc(31, 0)),
executed_state::subtrace_lore(11, subtrace_desc(29, 2), subtrace_desc(31, 0)),
]),
executed_state::par(1, 2),
executed_state::scalar_string(unit_call_service_result),
@ -389,11 +389,11 @@ fn fold_par_early_exit() {
executed_state::par(15, 0),
executed_state::par(13, 1),
executed_state::fold(vec![
executed_state::subtrace_lore(8, SubTraceDesc::new(35, 6), SubTraceDesc::new(47, 0)),
executed_state::subtrace_lore(9, SubTraceDesc::new(41, 6), SubTraceDesc::new(47, 0)),
executed_state::subtrace_lore(8, subtrace_desc(35, 6), subtrace_desc(47, 0)),
executed_state::subtrace_lore(9, subtrace_desc(41, 6), subtrace_desc(47, 0)),
]),
];
let trace_len = expected_trace.len();
assert_eq!(&actual_trace[0..trace_len], expected_trace);
assert_eq!((*actual_trace)[0..trace_len], expected_trace);
}

2
air/tests/test_module/features/tetraplets/security_tetraplets.rs
View File

@ -286,5 +286,5 @@ fn tetraplet_with_wasm_modules() {
let actual_trace = trace_from_result(&result);
let expected_state = executed_state::scalar_string("Ok");
assert_eq!(actual_trace[1], expected_state)
assert_eq!(actual_trace[1.into()], expected_state)
}

4
air/tests/test_module/instructions/call.rs
View File

@ -97,7 +97,7 @@ fn remote_peer_id_call() {
let expected_state = executed_state::request_sent_by(some_local_peer_id);
assert_eq!(actual_trace.len(), 1);
assert_eq!(actual_trace[0], expected_state);
assert_eq!(actual_trace[0.into()], expected_state);
assert_eq!(result.next_peer_pks, vec![remote_peer_id]);
}
@ -169,5 +169,5 @@ fn string_parameters() {
let expected_state = executed_state::scalar_string("arg1");
assert_eq!(actual_trace.len(), 2);
assert_eq!(actual_trace[1], expected_state);
assert_eq!(actual_trace[1.into()], expected_state);
}

20
air/tests/test_module/instructions/fold.rs
View File

@ -44,11 +44,11 @@ fn lfold() {
let expected_state = executed_state::scalar_string_array(vec!["1", "2", "3", "4", "5"]);
assert_eq!(actual_trace.len(), 6);
assert_eq!(actual_trace[0], expected_state);
assert_eq!(actual_trace[0.into()], expected_state);
for i in 1..=5 {
let expected_state = executed_state::stream_string(format!("{}", i), i as u32 - 1);
assert_eq!(actual_trace[i], expected_state);
assert_eq!(actual_trace[i.into()], expected_state);
}
}
@ -78,11 +78,11 @@ fn rfold() {
assert_eq!(actual_trace.len(), 6);
let expected_state = executed_state::scalar_string_array(vec!["1", "2", "3", "4", "5"]);
assert_eq!(actual_trace[0], expected_state);
assert_eq!(actual_trace[0.into()], expected_state);
for i in 1..=5 {
let expected_state = executed_state::stream_string(format!("{}", 6 - i), i as u32 - 1);
assert_eq!(actual_trace[i], expected_state);
assert_eq!(actual_trace[i.into()], expected_state);
}
}
@ -120,14 +120,14 @@ fn inner_fold() {
assert_eq!(actual_trace.len(), 27);
let expected_state = executed_state::scalar_string_array(vec!["1", "2", "3", "4", "5"]);
assert_eq!(actual_trace[0], expected_state);
assert_eq!(actual_trace[1], expected_state);
assert_eq!(actual_trace[0.into()], expected_state);
assert_eq!(actual_trace[1.into()], expected_state);
for i in 1..=5 {
for j in 1..=5 {
let state_id = 1 + 5 * (i - 1) + j;
let expected_state = executed_state::stream_string(i.to_string(), state_id as u32 - 2);
assert_eq!(actual_trace[state_id], expected_state);
assert_eq!(actual_trace[state_id.into()], expected_state);
}
}
}
@ -187,7 +187,7 @@ fn empty_iterable_fold() {
let expected_state = executed_state::scalar(json!([]));
assert_eq!(actual_trace.len(), 1);
assert_eq!(actual_trace[0], expected_state);
assert_eq!(actual_trace[0.into()], expected_state);
}
#[test]
@ -286,11 +286,11 @@ fn lambda() {
let expected_state = executed_state::scalar(json!({ "array": ["1", "2", "3", "4", "5"] }));
assert_eq!(actual_trace.len(), 6);
assert_eq!(actual_trace[0], expected_state);
assert_eq!(actual_trace[0.into()], expected_state);
for i in 1..=5 {
let expected_state = executed_state::stream_string(format!("{}", i), i as u32 - 1);
assert_eq!(actual_trace[i], expected_state);
assert_eq!(actual_trace[i.into()], expected_state);
}
}

12
air/tests/test_module/instructions/match_.rs
View File

@ -46,7 +46,7 @@ fn match_equal() {
let expected_state = executed_state::scalar_string("result_1");
assert_eq!(actual_trace.len(), 3);
assert_eq!(actual_trace[2], expected_state);
assert_eq!(actual_trace[2.into()], expected_state);
}
#[test]
@ -78,7 +78,7 @@ fn match_not_equal() {
let expected_state = executed_state::scalar_string("result_2");
assert_eq!(actual_trace.len(), 3);
assert_eq!(actual_trace[2], expected_state);
assert_eq!(actual_trace[2.into()], expected_state);
}
#[test]
@ -107,7 +107,7 @@ fn match_with_string() {
let expected_state = executed_state::scalar_string("result_1");
assert_eq!(actual_trace.len(), 2);
assert_eq!(actual_trace[1], expected_state);
assert_eq!(actual_trace[1.into()], expected_state);
}
#[test]
@ -137,7 +137,7 @@ fn match_with_init_peer_id() {
let expected_executed_call_result = executed_state::scalar_string("result_1");
assert_eq!(actual_trace.len(), 2);
assert_eq!(actual_trace[1], expected_executed_call_result);
assert_eq!(actual_trace[1.into()], expected_executed_call_result);
}
#[test]
@ -168,7 +168,7 @@ fn match_with_timestamp() {
let expected_executed_call_result = executed_state::scalar_string("result_1");
assert_eq!(actual_trace.len(), 2);
assert_eq!(actual_trace[1], expected_executed_call_result);
assert_eq!(actual_trace[1.into()], expected_executed_call_result);
}
#[test]
@ -199,7 +199,7 @@ fn match_with_ttl() {
let expected_executed_call_result = executed_state::scalar_string("result_1");
assert_eq!(actual_trace.len(), 2);
assert_eq!(actual_trace[1], expected_executed_call_result);
assert_eq!(actual_trace[1.into()], expected_executed_call_result);
}
#[test]

6
air/tests/test_module/instructions/mismatch.rs
View File

@ -46,7 +46,7 @@ fn mismatch_equal() {
let expected_state = executed_state::scalar_string("result_2");
assert_eq!(actual_trace.len(), 3);
assert_eq!(actual_trace[2], expected_state);
assert_eq!(actual_trace[2.into()], expected_state);
}
#[test]
@ -78,7 +78,7 @@ fn mismatch_not_equal() {
let expected_state = executed_state::scalar_string("result_1");
assert_eq!(actual_trace.len(), 3);
assert_eq!(actual_trace[2], expected_state);
assert_eq!(actual_trace[2.into()], expected_state);
}
#[test]
@ -107,7 +107,7 @@ fn mismatch_with_string() {
let expected_state = executed_state::scalar_string("result_2");
assert_eq!(actual_trace.len(), 2);
assert_eq!(actual_trace[1], expected_state);
assert_eq!(actual_trace[1.into()], expected_state);
}
#[test]

4
air/tests/test_module/instructions/new.rs
View File

@ -74,8 +74,8 @@ fn new_with_global_streams_seq() {
executed_state::stream_number(1, 0),
executed_state::stream_number(2, 0),
executed_state::fold(vec![
executed_state::subtrace_lore(0, SubTraceDesc::new(3, 1), SubTraceDesc::new(7, 2)),
executed_state::subtrace_lore(1, SubTraceDesc::new(4, 1), SubTraceDesc::new(5, 2)),
executed_state::subtrace_lore(0, SubTraceDesc::new(3.into(), 1), SubTraceDesc::new(7.into(), 2)),
executed_state::subtrace_lore(1, SubTraceDesc::new(4.into(), 1), SubTraceDesc::new(5.into(), 2)),
]),
executed_state::stream_number(1, 0),
executed_state::stream_number(2, 0),

12
air/tests/test_module/instructions/xor.rs
View File

@ -36,10 +36,10 @@ fn xor() {
assert_eq!(actual_trace.len(), 2);
assert_eq!(
actual_trace[0],
actual_trace[0.into()],
executed_state::service_failed(1, "failed result from fallible_call_service")
);
assert_eq!(actual_trace[1], expected_call_result);
assert_eq!(actual_trace[1.into()], expected_call_result);
let script = f!(r#"
(xor
@ -51,7 +51,7 @@ fn xor() {
let actual_trace = trace_from_result(&result);
assert_eq!(actual_trace.len(), 1);
assert_eq!(actual_trace[0], expected_call_result);
assert_eq!(actual_trace[0.into()], expected_call_result);
}
#[test]
@ -71,8 +71,8 @@ fn xor_var_not_found() {
let result = checked_call_vm!(vm, <_>::default(), script, "", "");
let actual_trace = trace_from_result(&result);
assert_eq!(actual_trace[0], executed_state::par(1, 0));
assert_eq!(actual_trace[1], executed_state::request_sent_by(local_peer_id));
assert_eq!(actual_trace[0.into()], executed_state::par(1, 0));
assert_eq!(actual_trace[1.into()], executed_state::request_sent_by(local_peer_id));
}
#[test]
@ -171,5 +171,5 @@ fn last_error_with_xor() {
r#"Local service error, ret_code is 1, error message is '"failed result from fallible_call_service"'"#,
);
assert_eq!(actual_trace[1], expected_state);
assert_eq!(actual_trace[1.into()], expected_state);
}

4
air/tests/test_module/issues/issue_173.rs
View File

@ -75,8 +75,8 @@ fn issue_173() {
executed_state::stream_number(1, 0),
executed_state::stream_number(2, 0),
executed_state::fold(vec![
executed_state::subtrace_lore(0, SubTraceDesc::new(3, 2), SubTraceDesc::new(9, 2)),
executed_state::subtrace_lore(1, SubTraceDesc::new(5, 2), SubTraceDesc::new(7, 2)),
executed_state::subtrace_lore(0, SubTraceDesc::new(3.into(), 2), SubTraceDesc::new(9.into(), 2)),
executed_state::subtrace_lore(1, SubTraceDesc::new(5.into(), 2), SubTraceDesc::new(7.into(), 2)),
]),
executed_state::par(6, 1),
executed_state::stream_number(1, 0),

4
air/tests/test_module/issues/issue_221.rs
View File

@ -94,8 +94,8 @@ fn issue_221() {
executed_state::scalar_string(peer_2_value),
executed_state::ap(Some(1)),
executed_state::fold(vec![
executed_state::subtrace_lore(3, SubTraceDesc::new(8, 4), SubTraceDesc::new(12, 0)),
executed_state::subtrace_lore(6, SubTraceDesc::new(12, 4), SubTraceDesc::new(16, 0)),
executed_state::subtrace_lore(3, SubTraceDesc::new(8.into(), 4), SubTraceDesc::new(12.into(), 0)),
executed_state::subtrace_lore(6, SubTraceDesc::new(12.into(), 4), SubTraceDesc::new(16.into(), 0)),
]),
executed_state::par(3, 0),
executed_state::par(1, 1),

4
air/tests/test_module/issues/issue_222.rs
View File

@ -70,8 +70,8 @@ fn issue_222() {
executed_state::stream(json!([1]), 0),
executed_state::stream(json!([2]), 0),
executed_state::fold(vec![
executed_state::subtrace_lore(2, SubTraceDesc::new(5, 1), SubTraceDesc::new(7, 0)),
executed_state::subtrace_lore(3, SubTraceDesc::new(6, 1), SubTraceDesc::new(7, 0)),
executed_state::subtrace_lore(2, SubTraceDesc::new(5.into(), 1), SubTraceDesc::new(7.into(), 0)),
executed_state::subtrace_lore(3, SubTraceDesc::new(6.into(), 1), SubTraceDesc::new(7.into(), 0)),
]),
executed_state::scalar(json!([1])),
executed_state::scalar(json!([2])),

6
crates/air-lib/interpreter-data/src/executed_state.rs
View File

@ -17,6 +17,8 @@
mod impls;
mod se_de;
use crate::TracePos;
use se_de::par_serializer;
use se_de::sender_serializer;
use serde::Deserialize;
@ -82,7 +84,7 @@ pub enum Value {
pub struct FoldSubTraceLore {
/// Position of current value in a trace.
#[serde(rename = "pos")]
pub value_pos: u32,
pub value_pos: TracePos,
/// Descriptors of a subtrace that are corresponded to the current value. Technically, now
/// it always contains two values, and Vec here is used to have a possibility to handle more
@ -97,7 +99,7 @@ pub struct FoldSubTraceLore {
pub struct SubTraceDesc {
/// Start position in a trace of this subtrace.
#[serde(rename = "pos")]
pub begin_pos: u32,
pub begin_pos: TracePos,
/// Length of the subtrace.
#[serde(rename = "len")]

4
crates/air-lib/interpreter-data/src/executed_state/impls.rs
View File

@ -59,9 +59,9 @@ impl CallResult {
}
impl SubTraceDesc {
pub fn new(begin_pos: usize, subtrace_len: usize) -> Self {
pub fn new(begin_pos: TracePos, subtrace_len: usize) -> Self {
Self {
begin_pos: begin_pos as _,
begin_pos,
subtrace_len: subtrace_len as _,
}
}

4
crates/air-lib/interpreter-data/src/interpreter_data.rs
View File

@ -14,16 +14,14 @@
* limitations under the License.
*/
use super::ExecutedState;
use super::GlobalStreamGens;
use super::RestrictedStreamGens;
use super::DATA_FORMAT_VERSION;
use crate::ExecutionTrace;
use serde::Deserialize;
use serde::Serialize;
use std::ops::Deref;
pub type ExecutionTrace = Vec<ExecutedState>;
/// The AIR interpreter could be considered as a function
/// f(prev_data: InterpreterData, current_data: InterpreterData, ... ) -> (result_data: InterpreterData, ...).
/// This function receives prev and current data and produces a result data. All these data

4
crates/air-lib/interpreter-data/src/lib.rs
View File

@ -28,10 +28,14 @@
mod executed_state;
mod interpreter_data;
mod stream_generations;
mod trace;
mod trace_pos;
pub use executed_state::*;
pub use interpreter_data::*;
pub use stream_generations::*;
pub use trace::*;
pub use trace_pos::*;
use once_cell::sync::Lazy;
use std::str::FromStr;

75
crates/air-lib/interpreter-data/src/trace.rs Normal file
View File

@ -0,0 +1,75 @@
/*
* Copyright 2022 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
use super::ExecutedState;
use crate::TracePos;
use serde::Deserialize;
use serde::Serialize;
use std::ops::Deref;
use std::ops::Index;
use std::ops::IndexMut;
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(transparent)]
pub struct ExecutionTrace(Vec<ExecutedState>);
impl ExecutionTrace {
pub fn get(&self, index: TracePos) -> Option<&ExecutedState> {
self.0.get(usize::from(index))
}
pub fn pop(&mut self) -> Option<ExecutedState> {
self.0.pop()
}
pub fn push(&mut self, value: ExecutedState) {
self.0.push(value);
}
}
impl Deref for ExecutionTrace {
type Target = [ExecutedState];
fn deref(&self) -> &[ExecutedState] {
&self.0
}
}
impl From<Vec<ExecutedState>> for ExecutionTrace {
fn from(vec: Vec<ExecutedState>) -> Self {
Self(vec)
}
}
impl Index<TracePos> for ExecutionTrace {
type Output = ExecutedState;
fn index(&self, index: TracePos) -> &Self::Output {
&self.deref()[usize::from(index)]
}
}
impl IndexMut<TracePos> for ExecutionTrace {
fn index_mut(&mut self, index: TracePos) -> &mut Self::Output {
&mut self.0[usize::from(index)]
}
}
impl PartialEq<Vec<ExecutedState>> for ExecutionTrace {
fn eq(&self, other: &Vec<ExecutedState>) -> bool {
&self.0 == other
}
}

86
crates/air-lib/interpreter-data/src/trace_pos.rs Normal file
View File

@ -0,0 +1,86 @@
/*
* Copyright 2022 Fluence Labs Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
use serde::{Deserialize, Serialize};
use std::{
fmt::{Debug, Display},
ops::{Add, AddAssign, Sub},
};
#[derive(Copy, Clone, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
#[serde(transparent)]
#[repr(transparent)]
pub struct TracePos(usize);
impl TracePos {
pub fn checked_add(self, other: usize) -> Option<Self> {
self.0.checked_add(other).map(Self)
}
}
impl Debug for TracePos {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
Debug::fmt(&self.0, f)
}
}
impl Display for TracePos {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
Display::fmt(&self.0, f)
}
}
impl From<usize> for TracePos {
fn from(pos: usize) -> Self {
TracePos(pos)
}
}
impl From<TracePos> for usize {
fn from(pos: TracePos) -> Self {
pos.0
}
}
impl AddAssign<usize> for TracePos {
fn add_assign(&mut self, rhs: usize) {
self.0 += rhs;
}
}
impl Add<usize> for TracePos {
type Output = Self;
fn add(self, rhs: usize) -> Self::Output {
TracePos(self.0 + rhs)
}
}
impl Sub<usize> for TracePos {
type Output = Self;
fn sub(self, rhs: usize) -> Self::Output {
TracePos(self.0 - rhs)
}
}
impl Sub<TracePos> for TracePos {
type Output = usize;
fn sub(self, rhs: TracePos) -> Self::Output {
self.0 - rhs.0
}
}

12
crates/air-lib/test-utils/src/executed_state.rs
View File

@ -20,6 +20,7 @@ use super::ExecutedState;
use super::JValue;
use super::ParResult;
use super::Sender;
use super::TracePos;
use super::Value;
use crate::FoldLore;
use crate::FoldResult;
@ -113,16 +114,23 @@ pub fn fold(lore: FoldLore) -> ExecutedState {
}
pub fn subtrace_lore(
value_pos: u32,
value_pos: usize,
before: SubTraceDesc,
after: SubTraceDesc,
) -> FoldSubTraceLore {
FoldSubTraceLore {
value_pos,
value_pos: value_pos.into(),
subtraces_desc: vec![before, after],
}
}
pub fn subtrace_desc(begin_pos: impl Into<TracePos>, subtrace_len: u32) -> SubTraceDesc {
SubTraceDesc {
begin_pos: begin_pos.into(),
subtrace_len,
}
}
pub fn ap(dst: Option<u32>) -> ExecutedState {
let res_generations = option_to_vec(dst);
let ap_result = ApResult::new(res_generations);

5
crates/air-lib/test-utils/src/lib.rs
View File

@ -89,8 +89,9 @@ pub fn data_from_result(result: &RawAVMOutcome) -> InterpreterData {
serde_json::from_slice(&result.data).expect("default serializer shouldn't fail")
}
pub fn raw_data_from_trace(trace: ExecutionTrace) -> Vec<u8> {
let data = InterpreterData::from_execution_result(trace, <_>::default(), <_>::default(), 0);
pub fn raw_data_from_trace(trace: impl Into<ExecutionTrace>) -> Vec<u8> {
let data =
InterpreterData::from_execution_result(trace.into(), <_>::default(), <_>::default(), 0);
serde_json::to_vec(&data).expect("default serializer shouldn't fail")
}

7
crates/air-lib/trace-handler/src/data_keeper/errors.rs
View File

@ -15,6 +15,7 @@
*/
use super::ExecutedState;
use crate::TracePos;
use thiserror::Error as ThisError;
/// Errors arose out while accessing various interpreter data.
@ -27,7 +28,7 @@ pub enum KeeperError {
)]
SetSubtraceLenFailed {
requested_subtrace_len: usize,
trace_position: usize,
trace_position: TracePos,
trace_len: usize,
},
@ -38,7 +39,7 @@ pub enum KeeperError {
but tried to set {requested_subtrace_len} subtrace_len and {requested_pos} position"
)]
SetSubtraceLenAndPosFailed {
requested_pos: usize,
requested_pos: TracePos,
requested_subtrace_len: usize,
trace_len: usize,
},
@ -46,7 +47,7 @@ pub enum KeeperError {
/// Errors occurred when Fold FSM tries to obtain stream generation by value_pos from a trace,
/// but this value_pos is bigger than the trace length.
#[error("requested an element at position '{position}', but executed trace contains only '{trace_len}' elements")]
NoElementAtPosition { position: usize, trace_len: usize },
NoElementAtPosition { position: TracePos, trace_len: usize },
/// Errors occurred when Fold FSM tries to obtain stream generation by value_pos from a trace,
/// but such state doesn't belong to values in streams (it doesn't contain a generation).

11
crates/air-lib/trace-handler/src/data_keeper/keeper.rs
View File

@ -17,6 +17,7 @@
use super::ExecutionTrace;
use super::MergeCtx;
use super::TraceSlider;
use crate::TracePos;
use air_interpreter_data::InterpreterData;
@ -27,7 +28,7 @@ use std::collections::HashMap;
pub(crate) struct DataKeeper {
pub(crate) prev_ctx: MergeCtx,
pub(crate) current_ctx: MergeCtx,
pub(crate) new_to_old_pos: HashMap<usize, DataPositions>,
pub(crate) new_to_old_pos: HashMap<TracePos, DataPositions>,
pub(crate) result_trace: ExecutionTrace,
}
@ -48,6 +49,10 @@ impl DataKeeper {
self.result_trace.len()
}
pub(crate) fn result_trace_next_pos(&self) -> TracePos {
self.result_trace.len().into()
}
pub(crate) fn prev_slider(&self) -> &TraceSlider {
&self.prev_ctx.slider
}
@ -67,6 +72,6 @@ impl DataKeeper {
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
pub(crate) struct DataPositions {
pub(crate) prev_pos: Option<usize>,
pub(crate) current_pos: Option<usize>,
pub(crate) prev_pos: Option<TracePos>,
pub(crate) current_pos: Option<TracePos>,
}

4
crates/air-lib/trace-handler/src/data_keeper/merge_ctx.rs
View File

@ -18,6 +18,7 @@ use super::ExecutionTrace;
use super::KeeperError;
use super::KeeperResult;
use super::TraceSlider;
use crate::TracePos;
use air_interpreter_data::GlobalStreamGens;
use air_interpreter_data::InterpreterData;
@ -51,10 +52,9 @@ impl MergeCtx {
}
}
pub(crate) fn try_get_generation(&self, position: u32) -> KeeperResult<u32> {
pub(crate) fn try_get_generation(&self, position: TracePos) -> KeeperResult<u32> {
use air_interpreter_data::*;
let position = position as usize;
let state = self
.slider
.state_at_position(position)

20
crates/air-lib/trace-handler/src/data_keeper/trace_slider.rs
View File

@ -18,6 +18,7 @@ use super::ExecutedState;
use super::ExecutionTrace;
use super::KeeperError::*;
use super::KeeperResult;
use crate::TracePos;
/// This slider is intended to slide on a subtrace inside provided trace. This subtrace
/// is identified by position and len.
@ -28,7 +29,7 @@ pub struct TraceSlider {
trace: ExecutionTrace,
/// Position of current subtrace inside trace.
position: usize,
position: TracePos,
/// Length of a current subtrace.
subtrace_len: usize,
@ -38,7 +39,8 @@ pub struct TraceSlider {
}
impl TraceSlider {
pub(crate) fn new(trace: ExecutionTrace) -> Self {
pub(crate) fn new(trace: impl Into<ExecutionTrace>) -> Self {
let trace = trace.into();
let subtrace_len = trace.len();
Self {
@ -52,7 +54,7 @@ impl TraceSlider {
/// and None otherwise.
#[allow(clippy::suspicious_operation_groupings)]
pub(crate) fn next_state(&mut self) -> Option<ExecutedState> {
if self.seen_elements >= self.subtrace_len || self.position >= self.trace.len() {
if self.seen_elements >= self.subtrace_len || usize::from(self.position) >= self.trace.len() {
return None;
}
@ -62,9 +64,10 @@ impl TraceSlider {
Some(result)
}
pub(crate) fn set_position_and_len(&mut self, position: usize, subtrace_len: usize) -> KeeperResult<()> {
pub(crate) fn set_position_and_len(&mut self, position: TracePos, subtrace_len: usize) -> KeeperResult<()> {
let pos: usize = position.into();
// it's possible to set empty subtrace_len and inconsistent position
if subtrace_len != 0 && position + subtrace_len > self.trace.len() {
if subtrace_len != 0 && pos + subtrace_len > self.trace.len() {
return Err(SetSubtraceLenAndPosFailed {
requested_pos: position,
requested_subtrace_len: subtrace_len,
@ -80,7 +83,7 @@ impl TraceSlider {
}
pub(crate) fn set_subtrace_len(&mut self, subtrace_len: usize) -> KeeperResult<()> {
let trace_remainder = self.trace.len() - self.position;
let trace_remainder = self.trace.len() - usize::from(self.position);
if trace_remainder < subtrace_len {
return Err(SetSubtraceLenFailed {
requested_subtrace_len: subtrace_len,
@ -95,7 +98,7 @@ impl TraceSlider {
Ok(())
}
pub(crate) fn position(&self) -> usize {
pub(crate) fn position(&self) -> TracePos {
self.position
}
@ -103,7 +106,8 @@ impl TraceSlider {
self.subtrace_len - self.seen_elements
}
pub(super) fn state_at_position(&self, position: usize) -> Option<&ExecutedState> {
pub(super) fn state_at_position(&self, position: TracePos) -> Option<&ExecutedState> {
// it would be nice to have the `impl SliceIndex for TracePos`, but it is unstable
self.trace.get(position)
}

6
crates/air-lib/trace-handler/src/handler.rs
View File

@ -38,8 +38,8 @@ impl TraceHandler {
/// Returns size of elements inside result trace and intended to provide
/// a position of next inserted elements.
pub fn trace_pos(&self) -> usize {
self.data_keeper.result_trace.len()
pub fn trace_pos(&self) -> TracePos {
self.data_keeper.result_trace.len().into()
}
pub fn into_result_trace(self) -> ExecutionTrace {
@ -120,7 +120,7 @@ impl TraceHandler {
Ok(())
}
pub fn meet_iteration_start(&mut self, fold_id: u32, value_pos: usize) -> TraceHandlerResult<()> {
pub fn meet_iteration_start(&mut self, fold_id: u32, value_pos: TracePos) -> TraceHandlerResult<()> {
let fold_fsm = self.fsm_keeper.fold_mut(fold_id)?;
fold_fsm.meet_iteration_start(value_pos, &mut self.data_keeper)?;

5
crates/air-lib/trace-handler/src/merger/call_merger.rs
View File

@ -17,6 +17,7 @@
mod utils;
use super::*;
use crate::TracePos;
use air_parser::ast::CallOutputValue;
use utils::*;
@ -29,7 +30,7 @@ pub enum MergerCallResult {
/// There was a state in at least one of the contexts. If there were two states in
/// both contexts, they were successfully merged.
CallResult { value: CallResult, trace_pos: usize },
CallResult { value: CallResult, trace_pos: TracePos },
}
pub(crate) fn try_merge_next_state_as_call(
@ -102,7 +103,7 @@ pub(super) fn prepare_call_result(
scheme: PreparationScheme,
data_keeper: &mut DataKeeper,
) -> MergerCallResult {
let trace_pos = data_keeper.result_states_count();
let trace_pos = data_keeper.result_trace_next_pos();
prepare_positions_mapping(scheme, data_keeper);
MergerCallResult::CallResult { value, trace_pos }

3
crates/air-lib/trace-handler/src/merger/errors.rs
View File

@ -22,6 +22,7 @@ use super::FoldResult;
use super::KeeperError;
use super::Value;
use air_interpreter_data::TracePos;
use thiserror::Error as ThisError;
/// Errors arose out of merging previous data with a new.
@ -79,7 +80,7 @@ pub enum FoldResultError {
/// There are several lores with the same value_pos.
#[error("{0:?} contains several subtraces with the same value_pos {1}")]
SeveralRecordsWithSamePos(FoldResult, usize),
SeveralRecordsWithSamePos(FoldResult, TracePos),
/// Errors occurred when one of the fold subtrace lore doesn't contain 2 descriptors.
#[error("fold contains {0} sublore descriptors, but 2 is expected")]

63
crates/air-lib/trace-handler/src/merger/fold_merger/fold_lore_resolver.rs
View File

@ -19,12 +19,13 @@ use crate::data_keeper::MergeCtx;
use air_interpreter_data::FoldSubTraceLore;
use air_interpreter_data::SubTraceDesc;
use air_interpreter_data::TracePos;
use std::collections::HashMap;
#[derive(Debug, Default, Clone, PartialEq, Eq)]
pub struct ResolvedFold {
pub lore: HashMap<usize, ResolvedSubTraceDescs>,
pub lore: HashMap<TracePos, ResolvedSubTraceDescs>,
pub fold_states_count: usize,
}
@ -40,16 +41,14 @@ pub(super) fn resolve_fold_lore(fold: &FoldResult, merge_ctx: &MergeCtx) -> Merg
let lore = fold.lore.iter().zip(lens).try_fold::<_, _, MergeResult<_>>(
HashMap::with_capacity(fold.lore.len()),
|mut resolved_lore, (lore, lens)| {
let before_subtrace = SubTraceDesc::new(lore.subtraces_desc[0].begin_pos as _, lens.before_len as _);
let after_subtrace = SubTraceDesc::new(lore.subtraces_desc[1].begin_pos as _, lens.after_len as _);
let before_subtrace = SubTraceDesc::new(lore.subtraces_desc[0].begin_pos, lens.before_len as _);
let after_subtrace = SubTraceDesc::new(lore.subtraces_desc[1].begin_pos, lens.after_len as _);
let resolved_descs = ResolvedSubTraceDescs::new(before_subtrace, after_subtrace);
match resolved_lore.insert(lore.value_pos as usize, resolved_descs) {
Some(_) => Err(FoldResultError::SeveralRecordsWithSamePos(
fold.clone(),
lore.value_pos as usize,
))
.map_err(Into::into),
match resolved_lore.insert(lore.value_pos, resolved_descs) {
Some(_) => {
Err(FoldResultError::SeveralRecordsWithSamePos(fold.clone(), lore.value_pos)).map_err(Into::into)
}
None => Ok(resolved_lore),
}
},
@ -156,7 +155,7 @@ fn check_subtrace_lore(subtrace_lore: &FoldSubTraceLore) -> MergeResult<()> {
}
impl ResolvedFold {
pub(crate) fn new(lore: HashMap<usize, ResolvedSubTraceDescs>, fold_states_count: usize) -> Self {
pub(crate) fn new(lore: HashMap<TracePos, ResolvedSubTraceDescs>, fold_states_count: usize) -> Self {
Self {
lore,
fold_states_count,
@ -196,6 +195,14 @@ mod tests {
use air_interpreter_data::FoldResult;
use air_interpreter_data::FoldSubTraceLore;
use air_interpreter_data::SubTraceDesc;
use air_interpreter_data::TracePos;
fn subtrace_desc(begin_pos: impl Into<TracePos>, subtrace_len: u32) -> SubTraceDesc {
SubTraceDesc {
begin_pos: begin_pos.into(),
subtrace_len,
}
}
#[test]
fn empty_fold_result() {
@ -221,16 +228,16 @@ mod tests {
// g0 g0 g0
let lore = vec![
FoldSubTraceLore {
value_pos: 0,
subtraces_desc: vec![SubTraceDesc::new(0, 1), SubTraceDesc::new(0, 1)],
value_pos: 0.into(),
subtraces_desc: vec![subtrace_desc(0, 1), subtrace_desc(0, 1)],
},
FoldSubTraceLore {
value_pos: 0,
subtraces_desc: vec![SubTraceDesc::new(0, 2), SubTraceDesc::new(0, 2)],
value_pos: 0.into(),
subtraces_desc: vec![subtrace_desc(0, 2), subtrace_desc(0, 2)],
},
FoldSubTraceLore {
value_pos: 0,
subtraces_desc: vec![SubTraceDesc::new(0, 3), SubTraceDesc::new(0, 3)],
value_pos: 0.into(),
subtraces_desc: vec![subtrace_desc(0, 3), subtrace_desc(0, 3)],
},
];
@ -256,28 +263,28 @@ mod tests {
// g0 g0 g0 g1 g1 g2
let lore = vec![
FoldSubTraceLore {
value_pos: 0,
subtraces_desc: vec![SubTraceDesc::new(0, 1), SubTraceDesc::new(0, 1)],
value_pos: 0.into(),
subtraces_desc: vec![subtrace_desc(0, 1), subtrace_desc(0, 1)],
},
FoldSubTraceLore {
value_pos: 0,
subtraces_desc: vec![SubTraceDesc::new(0, 2), SubTraceDesc::new(0, 2)],
value_pos: 0.into(),
subtraces_desc: vec![subtrace_desc(0, 2), subtrace_desc(0, 2)],
},
FoldSubTraceLore {
value_pos: 0,
subtraces_desc: vec![SubTraceDesc::new(0, 3), SubTraceDesc::new(0, 3)],
value_pos: 0.into(),
subtraces_desc: vec![subtrace_desc(0, 3), subtrace_desc(0, 3)],
},
FoldSubTraceLore {
value_pos: 1,
subtraces_desc: vec![SubTraceDesc::new(0, 4), SubTraceDesc::new(0, 4)],
value_pos: 1.into(),
subtraces_desc: vec![subtrace_desc(0, 4), subtrace_desc(0, 4)],
},
FoldSubTraceLore {
value_pos: 1,
subtraces_desc: vec![SubTraceDesc::new(0, 5), SubTraceDesc::new(0, 5)],
value_pos: 1.into(),
subtraces_desc: vec![subtrace_desc(0, 5), subtrace_desc(0, 5)],
},
FoldSubTraceLore {
value_pos: 2,
subtraces_desc: vec![SubTraceDesc::new(0, 1), SubTraceDesc::new(0, 1)],
value_pos: 2.into(),
subtraces_desc: vec![subtrace_desc(0, 1), subtrace_desc(0, 1)],
},
];

2
crates/air-lib/trace-handler/src/merger/position_mapping.rs
View File

@ -40,6 +40,6 @@ pub(super) fn prepare_positions_mapping(scheme: PreparationScheme, data_keeper:
let data_positions = DataPositions { prev_pos, current_pos };
let trace_pos = data_keeper.result_states_count();
let trace_pos = data_keeper.result_trace_next_pos();
data_keeper.new_to_old_pos.insert(trace_pos, data_positions);
}

7
crates/air-lib/trace-handler/src/state_automata/errors.rs
View File

@ -18,6 +18,7 @@ use super::KeeperError;
use super::ParResult;
use crate::MergeCtxType;
use crate::ResolvedFold;
use crate::TracePos;
use thiserror::Error as ThisError;
@ -39,7 +40,7 @@ pub enum StateFSMError {
/// Errors occurred when slider.position() + ParResult.0 + ParResult.1 overflows.
#[error("overflow is occurred while calculating the new position of a {2} slider for resolved par {0:?} and current position {1}'")]
ParPosOverflow(ParResult, usize, MergeCtxType),
ParPosOverflow(ParResult, TracePos, MergeCtxType),
/// Errors occurred when ParResult.0 + ParResult.1 value is bigger than current subgraph size.
#[error("underflow is occurred while calculating the new position of a {2} slider for resolved par {0:?} and current subtrace len {1}'")]
@ -47,11 +48,11 @@ pub enum StateFSMError {
/// Errors occurred when {0}.fold_states_count + {1} overflows.
#[error("overflow is occurred while calculating the new position of a {2} slider for resolved fold {0:?} and current position {1}'")]
FoldPosOverflow(ResolvedFold, usize, MergeCtxType),
FoldPosOverflow(ResolvedFold, TracePos, MergeCtxType),
/// Errors occurred when {1} - 1{0}.fold_states_count underflows.
#[error("underflow is occurred while calculating the new position of a {2} slider for resolved fold {0:?} and current subtrace len {1}'")]
FoldLenUnderflow(ResolvedFold, usize, MergeCtxType),
FoldLenUnderflow(ResolvedFold, TracePos, MergeCtxType),
/// Errors bubbled from DataKeeper.
#[error(transparent)]

6
crates/air-lib/trace-handler/src/state_automata/fold_fsm.rs
View File

@ -19,6 +19,8 @@ mod lore_ctor;
mod lore_ctor_queue;
mod state_handler;
use crate::TracePos;
use super::*;
use lore_applier::*;
use lore_ctor::*;
@ -63,7 +65,7 @@ impl FoldFSM {
Ok(fold_fsm)
}
pub(crate) fn meet_iteration_start(&mut self, value_pos: usize, data_keeper: &mut DataKeeper) -> FSMResult<()> {
pub(crate) fn meet_iteration_start(&mut self, value_pos: TracePos, data_keeper: &mut DataKeeper) -> FSMResult<()> {
let (prev_pos, current_pos) = match data_keeper.new_to_old_pos.get(&value_pos) {
Some(DataPositions { prev_pos, current_pos }) => (prev_pos, current_pos),
None => return self.prepare(None, None, value_pos, data_keeper),
@ -79,7 +81,7 @@ impl FoldFSM {
&mut self,
prev_lore: Option<ResolvedSubTraceDescs>,
current_lore: Option<ResolvedSubTraceDescs>,
value_pos: usize,
value_pos: TracePos,
data_keeper: &mut DataKeeper,
) -> FSMResult<()> {
apply_fold_lore_before(data_keeper, &prev_lore, &current_lore)?;

26
crates/air-lib/trace-handler/src/state_automata/fold_fsm/lore_ctor.rs
View File

@ -20,7 +20,7 @@ use air_interpreter_data::SubTraceDesc;
/// This struct is a form of FSM and is intended to construct a fold subtrace lore element.
#[derive(Debug, Default, PartialEq, Eq, Clone, Copy)]
pub(super) struct SubTraceLoreCtor {
value_pos: usize,
value_pos: TracePos,
before_tracker: PositionsTracker,
after_tracker: PositionsTracker,
state: CtorState,
@ -28,8 +28,8 @@ pub(super) struct SubTraceLoreCtor {
#[derive(Debug, Default, PartialEq, Eq, Clone, Copy)]
struct PositionsTracker {
pub(self) start_pos: usize,
pub(self) end_pos: usize,
pub(self) start_pos: TracePos,
pub(self) end_pos: TracePos,
}
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
@ -41,10 +41,10 @@ pub enum CtorState {
}
impl SubTraceLoreCtor {
pub(super) fn from_before_start(value_pos: usize, data_keeper: &DataKeeper) -> Self {
pub(super) fn from_before_start(value_pos: TracePos, data_keeper: &DataKeeper) -> Self {
let before_tracker = PositionsTracker {
start_pos: data_keeper.result_states_count(),
end_pos: 0,
start_pos: data_keeper.result_trace_next_pos(),
end_pos: 0.into(),
};
Self {
@ -55,7 +55,7 @@ impl SubTraceLoreCtor {
}
pub(super) fn before_end(&mut self, data_keeper: &DataKeeper) {
self.before_tracker.end_pos = data_keeper.result_states_count();
self.before_tracker.end_pos = data_keeper.result_trace_next_pos();
self.state.next();
}
@ -64,33 +64,33 @@ impl SubTraceLoreCtor {
return;
}
self.before_tracker.end_pos = data_keeper.result_states_count();
self.before_tracker.end_pos = data_keeper.result_trace_next_pos();
self.state.next();
}
pub(super) fn after_start(&mut self, data_keeper: &DataKeeper) {
self.after_tracker.start_pos = data_keeper.result_states_count();
self.after_tracker.start_pos = data_keeper.result_trace_next_pos();
self.state.next();
}
pub(super) fn after_end(&mut self, data_keeper: &DataKeeper) {
self.after_tracker.end_pos = data_keeper.result_states_count();
self.after_tracker.end_pos = data_keeper.result_trace_next_pos();
self.state.next();
}
pub(super) fn into_subtrace_lore(self) -> FoldSubTraceLore {
let before = SubTraceDesc {
begin_pos: self.before_tracker.start_pos as _,
begin_pos: self.before_tracker.start_pos,
subtrace_len: self.before_tracker.len() as _,
};
let after = SubTraceDesc {
begin_pos: self.after_tracker.start_pos as _,
begin_pos: self.after_tracker.start_pos,
subtrace_len: self.after_tracker.len() as _,
};
FoldSubTraceLore {
value_pos: self.value_pos as _,
value_pos: self.value_pos,
subtraces_desc: vec![before, after],
}
}

1
crates/air-lib/trace-handler/src/state_automata/fold_fsm/state_handler.rs
View File

@ -58,6 +58,7 @@ fn compute_new_state(fold: &ResolvedFold, data_keeper: &DataKeeper, ctx_type: Me
let current_len = ctx.slider.subtrace_len();
let subtrace_len = current_len
.checked_sub(fold.fold_states_count)
// TODO judging by the error message, one should pass current_len instead.
.ok_or_else(|| StateFSMError::FoldLenUnderflow(fold.clone(), current_position, ctx_type))?;
let state = CtxState::new(pos, subtrace_len);

5
crates/air-lib/trace-handler/src/state_automata/state_inserter.rs
View File

@ -16,18 +16,19 @@
use super::DataKeeper;
use super::ExecutedState;
use air_interpreter_data::TracePos;
/// This one is intended to optimize insertion in data to avoid insertion in a middle of it.
/// This is achieved by inserting a temporary state, track insert position and insert there
/// the final state.
#[derive(Debug, Default, Clone)]
pub(super) struct StateInserter {
position: usize,
position: TracePos,
}
impl StateInserter {
pub(super) fn from_keeper(data_keeper: &mut DataKeeper) -> Self {
let position = data_keeper.result_trace.len();
let position = data_keeper.result_trace_next_pos();
// this par is a temporary state
data_keeper.result_trace.push(ExecutedState::par(0, 0));

5
crates/air-lib/trace-handler/src/state_automata/utils.rs
View File

@ -17,10 +17,11 @@
use super::DataKeeper;
use super::FSMResult;
use super::MergeCtx;
use crate::TracePos;
#[derive(Debug, Default, Clone, Copy)]
pub(super) struct CtxState {
pub(super) pos: usize,
pub(super) pos: TracePos,
pub(super) subtrace_len: usize,
}
@ -31,7 +32,7 @@ pub(super) struct CtxStatesPair {
}
impl CtxState {
pub(super) fn new(pos: usize, subtrace_len: usize) -> Self {
pub(super) fn new(pos: TracePos, subtrace_len: usize) -> Self {
Self { pos, subtrace_len }
}