mirror of
https://github.com/fluencelabs/aquavm
synced 2025-03-14 20:20:49 +00:00
8f587b7803
* Use CID values for tetraplets and `canon` vectors. * Rename `cid_store` to `value_store` It is consistent with the new `tetraplet_store` and `canon_store` fields. * Make canon data more typeful The `CanonResult` doesn't take a JSON value anymore that is further deserialized elsewhere, but is a struct that has all data deserialized. * Typeful `CID` type The `CID` type has a phantom type paramter defining its value's type. * Group cid stores and trackers Group cid stores into `CidInfo` struct, and trackers into `ExecutionCidState` struct.
340 lines
11 KiB
Rust
340 lines
11 KiB
Rust
/*
|
|
* Copyright 2020 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 air_test_utils::prelude::*;
|
|
|
|
use pretty_assertions::assert_eq;
|
|
|
|
use std::collections::HashMap;
|
|
use std::ops::Deref;
|
|
|
|
#[test]
|
|
fn merge_streams_in_two_fold() {
|
|
use executed_state::*;
|
|
|
|
let set_variable_peer_id = "set_variable_peer_id";
|
|
let vm_1_peer_id = "vm_1_peer_id";
|
|
let vm_2_peer_id = "vm_2_peer_id";
|
|
|
|
let mut set_variable = create_avm(
|
|
set_variable_call_service(json!([vm_1_peer_id, vm_2_peer_id])),
|
|
set_variable_peer_id,
|
|
);
|
|
let mut vm1 = create_avm(return_string_call_service(vm_1_peer_id), vm_1_peer_id);
|
|
let mut vm2 = create_avm(return_string_call_service(vm_2_peer_id), vm_2_peer_id);
|
|
|
|
let script = f!(r#"
|
|
(seq
|
|
(call "{set_variable_peer_id}" ("neighborhood" "") [] neighborhood)
|
|
(seq
|
|
(seq
|
|
(fold neighborhood i
|
|
(par
|
|
(call i ("add_provider" "") [] $void)
|
|
(next i)
|
|
)
|
|
)
|
|
(fold neighborhood i
|
|
(par
|
|
(call i ("get_providers" "") [] $providers)
|
|
(next i)
|
|
)
|
|
)
|
|
)
|
|
(seq
|
|
(call "{vm_1_peer_id}" ("identity" "") [] $void)
|
|
(call "{vm_2_peer_id}" ("" "") [] none)
|
|
)
|
|
)
|
|
)
|
|
"#);
|
|
|
|
let result_0 = checked_call_vm!(set_variable, <_>::default(), &script, "", "");
|
|
let result_1 = checked_call_vm!(vm1, <_>::default(), &script, "", result_0.data.clone());
|
|
let result_2 = checked_call_vm!(vm2, <_>::default(), &script, "", result_0.data);
|
|
let result_3 = checked_call_vm!(
|
|
vm1,
|
|
<_>::default(),
|
|
&script,
|
|
result_1.data.clone(),
|
|
result_2.data.clone()
|
|
);
|
|
let result_4 = checked_call_vm!(
|
|
vm2,
|
|
<_>::default(),
|
|
script,
|
|
result_1.data.clone(),
|
|
result_2.data.clone()
|
|
);
|
|
|
|
let actual_trace_1 = trace_from_result(&result_1);
|
|
|
|
let expected_trace_1 = vec![
|
|
scalar_string_array(vec![vm_1_peer_id, vm_2_peer_id]),
|
|
par(1, 2),
|
|
stream_string(vm_1_peer_id, 0),
|
|
par(1, 0),
|
|
request_sent_by(set_variable_peer_id),
|
|
par(1, 2),
|
|
stream_string(vm_1_peer_id, 0),
|
|
par(1, 0),
|
|
request_sent_by(vm_1_peer_id),
|
|
stream_string(vm_1_peer_id, 1),
|
|
request_sent_by(vm_1_peer_id),
|
|
];
|
|
|
|
assert_eq!(actual_trace_1, expected_trace_1);
|
|
assert_eq!(result_1.next_peer_pks, vec![vm_2_peer_id.to_string()]);
|
|
|
|
let actual_trace_2 = trace_from_result(&result_2);
|
|
|
|
let expected_trace_2 = vec![
|
|
scalar_string_array(vec![vm_1_peer_id, vm_2_peer_id]),
|
|
par(1, 2),
|
|
request_sent_by(set_variable_peer_id),
|
|
par(1, 0),
|
|
stream_string(vm_2_peer_id, 0),
|
|
par(1, 2),
|
|
request_sent_by(vm_2_peer_id),
|
|
par(1, 0),
|
|
stream_string(vm_2_peer_id, 0),
|
|
request_sent_by(vm_2_peer_id),
|
|
];
|
|
|
|
assert_eq!(actual_trace_2, expected_trace_2);
|
|
assert_eq!(result_2.next_peer_pks, vec![vm_1_peer_id.to_string()]);
|
|
|
|
let actual_trace_3 = trace_from_result(&result_3);
|
|
|
|
let expected_trace_3 = vec![
|
|
scalar_string_array(vec![vm_1_peer_id, vm_2_peer_id]),
|
|
par(1, 2),
|
|
stream_string(vm_1_peer_id, 0),
|
|
par(1, 0),
|
|
stream_string(vm_2_peer_id, 2),
|
|
par(1, 2),
|
|
stream_string(vm_1_peer_id, 0),
|
|
par(1, 0),
|
|
stream_string(vm_2_peer_id, 1),
|
|
stream_string(vm_1_peer_id, 1),
|
|
request_sent_by(vm_1_peer_id),
|
|
];
|
|
|
|
assert_eq!(actual_trace_3.deref(), expected_trace_3);
|
|
assert!(result_3.next_peer_pks.is_empty());
|
|
|
|
let actual_trace_4 = trace_from_result(&result_4);
|
|
|
|
let expected_trace_4 = vec![
|
|
scalar_string_array(vec![vm_1_peer_id, vm_2_peer_id]),
|
|
par(1, 2),
|
|
stream_string(vm_1_peer_id, 0),
|
|
par(1, 0),
|
|
stream_string(vm_2_peer_id, 2),
|
|
par(1, 2),
|
|
stream_string(vm_1_peer_id, 0),
|
|
par(1, 0),
|
|
stream_string(vm_2_peer_id, 1),
|
|
stream_string(vm_1_peer_id, 1),
|
|
scalar_string(vm_2_peer_id),
|
|
];
|
|
|
|
assert_eq!(actual_trace_4, expected_trace_4);
|
|
assert!(result_4.next_peer_pks.is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn stream_merge() {
|
|
let neighborhood_call_service: CallServiceClosure = Box::new(|params| -> CallServiceResult {
|
|
let args_count = (params.function_name.as_bytes()[0] - b'0') as usize;
|
|
let args: Vec<Vec<JValue>> = serde_json::from_value(JValue::Array(params.arguments)).expect("valid json");
|
|
assert_eq!(args[0].len(), args_count);
|
|
|
|
CallServiceResult::ok(json!(args))
|
|
});
|
|
|
|
let mut vm1 = create_avm(set_variable_call_service(json!("peer_id")), "A");
|
|
let mut vm2 = create_avm(neighborhood_call_service, "B");
|
|
|
|
let script = r#"
|
|
(seq
|
|
(call "A" ("add_provider" "") [] $void)
|
|
(seq
|
|
(call "A" ("add_provider" "") [] $void)
|
|
(seq
|
|
(call "A" ("get_providers" "") [] $providers)
|
|
(seq
|
|
(call "A" ("get_providers" "") [] $providers)
|
|
(seq
|
|
(seq
|
|
(canon "B" $providers #providers)
|
|
(call "B" ("" "2") [#providers] $void)
|
|
)
|
|
(seq
|
|
(canon "B" $void #void)
|
|
(call "B" ("" "3") [#void] $void)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
"#;
|
|
|
|
let result = checked_call_vm!(vm1, <_>::default(), script, "", "");
|
|
checked_call_vm!(vm2, <_>::default(), script, "", result.data);
|
|
}
|
|
|
|
#[test]
|
|
fn fold_merge() {
|
|
let set_variable_vm_id = "set_variable";
|
|
let local_vm_id = "local_vm";
|
|
|
|
let variables = maplit::hashmap! {
|
|
"stream_1".to_string() => json!(["peer_0", "peer_1", "peer_2", "peer_3"]),
|
|
"stream_2".to_string() => json!(["peer_4", "peer_5", "peer_6"]),
|
|
};
|
|
let mut set_variable_vm = create_avm(
|
|
set_variables_call_service(variables, VariableOptionSource::Argument(0)),
|
|
set_variable_vm_id,
|
|
);
|
|
|
|
let script = format!(
|
|
include_str!("./scripts/inner_folds_v1.air"),
|
|
set_variable_vm_id, local_vm_id
|
|
);
|
|
|
|
let set_variable_result = checked_call_vm!(set_variable_vm, <_>::default(), &script, "", "");
|
|
|
|
let mut local_vms = Vec::with_capacity(7);
|
|
let mut local_vms_results = Vec::with_capacity(7);
|
|
for vm_id in 0..7 {
|
|
let peer_id = f!("peer_{vm_id}");
|
|
let mut vm = create_avm(echo_call_service(), peer_id);
|
|
let result = checked_call_vm!(
|
|
vm,
|
|
<_>::default(),
|
|
&script,
|
|
set_variable_result.data.clone(),
|
|
set_variable_result.data.clone()
|
|
);
|
|
|
|
local_vms.push(vm);
|
|
local_vms_results.push(result);
|
|
}
|
|
|
|
let mut local_vm = create_avm(echo_call_service(), local_vm_id);
|
|
let result_1 = checked_call_vm!(local_vm, <_>::default(), &script, "", local_vms_results[0].data.clone());
|
|
let result_2 = checked_call_vm!(
|
|
local_vm,
|
|
<_>::default(),
|
|
&script,
|
|
result_1.data,
|
|
local_vms_results[3].data.clone()
|
|
);
|
|
let result_3 = checked_call_vm!(
|
|
local_vm,
|
|
<_>::default(),
|
|
&script,
|
|
result_2.data,
|
|
local_vms_results[4].data.clone()
|
|
);
|
|
let result_4 = checked_call_vm!(
|
|
local_vm,
|
|
<_>::default(),
|
|
&script,
|
|
result_3.data,
|
|
local_vms_results[5].data.clone()
|
|
);
|
|
|
|
let result_5 = checked_call_vm!(
|
|
local_vm,
|
|
<_>::default(),
|
|
&script,
|
|
result_4.data,
|
|
local_vms_results[1].data.clone()
|
|
);
|
|
|
|
let result_6 = checked_call_vm!(
|
|
local_vm,
|
|
<_>::default(),
|
|
&script,
|
|
result_5.data,
|
|
local_vms_results[2].data.clone()
|
|
);
|
|
|
|
let result_7 = checked_call_vm!(
|
|
local_vm,
|
|
<_>::default(),
|
|
&script,
|
|
result_6.data,
|
|
local_vms_results[6].data.clone()
|
|
);
|
|
|
|
let data = InterpreterData::try_from_slice(&result_7.data, &semver::Version::new(1, 1, 1))
|
|
.expect("data should be well-formed");
|
|
let stream_1_generations = data
|
|
.global_streams
|
|
.get("$stream_1")
|
|
.expect("$stream_1 should be present in data");
|
|
let stream_2_generations = data
|
|
.global_streams
|
|
.get("$stream_2")
|
|
.expect("$stream_2 should be present in data");
|
|
|
|
assert_eq!(*stream_1_generations, 8);
|
|
assert_eq!(*stream_2_generations, 6);
|
|
|
|
let mut fold_states_count = 0;
|
|
let mut calls_count = HashMap::new();
|
|
|
|
for state in data.trace.iter() {
|
|
if matches!(state, ExecutedState::Fold(_)) {
|
|
fold_states_count += 1;
|
|
}
|
|
|
|
if let ExecutedState::Fold(fold) = state {
|
|
for subtrace_lore in fold.lore.iter() {
|
|
let value_pos = subtrace_lore.value_pos;
|
|
if let ExecutedState::Call(CallResult::Executed(value)) = &data.trace[value_pos] {
|
|
let cid = match value {
|
|
ValueRef::Scalar(cid) => cid,
|
|
ValueRef::Stream { cid, .. } => cid,
|
|
};
|
|
|
|
let value = data.cid_info.value_store.get(cid).unwrap().clone();
|
|
if let JValue::String(ref var_name) = &*value {
|
|
let current_count: usize = calls_count.get(var_name).copied().unwrap_or_default();
|
|
calls_count.insert(var_name.to_owned(), current_count + 1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// $stream_1 contains 4 generation each with 2 elements, it means that inner fold for $stream_2
|
|
// runs 2*4 times and produces 2*4 fold states, and 1 state comes from fold for $stream_1
|
|
assert_eq!(fold_states_count, 2 * 4 + 1);
|
|
|
|
for (call_result, call_count) in calls_count {
|
|
if call_result.as_str() < "peer_4" {
|
|
assert_eq!(call_count, 2);
|
|
} else {
|
|
assert_eq!(call_count, 16);
|
|
}
|
|
}
|
|
}
|