Intrepid/Prometeu/Runtime/pipeline/pr-master This commit looks good
Add structural Fn signatures, typed capture environments, indirect calls and Trait dispatch while preserving logical parameter and result groups, ownership and budgets. Remove guest coroutine execution and legacy loading. Activate bounded sealed PBX v1 with mandatory capture metadata, preserve frame continuations and root return results, and migrate producers and shipped cartridges. Publish coordinated specs, handoffs and the completed runtime lesson. Validation: 880 workspace tests passed, 9 existing tests ignored; both cartridges completed six production-host frames.
1023 lines
40 KiB
Rust
1023 lines
40 KiB
Rust
use prometeu_bytecode::load_limits::{
|
|
LoadBudget, LoadCode, LoadFailure, LoadLimits, LoadReason, LoadResource,
|
|
};
|
|
use prometeu_bytecode::registry::*;
|
|
use prometeu_bytecode::registry_codec::*;
|
|
|
|
fn budget() -> LoadBudget {
|
|
LoadBudget::new(LoadLimits::default())
|
|
}
|
|
|
|
#[test]
|
|
fn fn_keys_ignore_names_but_preserve_logical_parameter_and_result_order() {
|
|
let signature = Signature { parameters: vec![named(0)], results: vec![TypeId(1)] };
|
|
let mut renamed = signature.clone();
|
|
renamed.parameters[0].name = Some("renamed".into());
|
|
let d = RegistryDeclarations {
|
|
types: vec![
|
|
builtin(BuiltinId::INT32),
|
|
builtin(BuiltinId::INT64),
|
|
TypeDecl { name: Some("a".into()), kind: TypeKind::Fn(signature.clone()) },
|
|
TypeDecl { name: Some("b".into()), kind: TypeKind::Fn(renamed) },
|
|
],
|
|
..Default::default()
|
|
};
|
|
let e = resolve(d).unwrap_err();
|
|
assert_eq!((e.code, e.reason), (LoadCode::InvalidRegistry, LoadReason::DuplicateFn));
|
|
let r = resolve(RegistryDeclarations {
|
|
types: vec![
|
|
builtin(BuiltinId::INT32),
|
|
builtin(BuiltinId::INT64),
|
|
TypeDecl { name: None, kind: TypeKind::Fn(signature) },
|
|
TypeDecl {
|
|
name: None,
|
|
kind: TypeKind::Fn(Signature {
|
|
parameters: vec![named(1)],
|
|
results: vec![TypeId(0)],
|
|
}),
|
|
},
|
|
],
|
|
..Default::default()
|
|
})
|
|
.unwrap();
|
|
let layout = r.type_layout(TypeId(2)).unwrap();
|
|
assert_eq!(layout.storage.slots, 1);
|
|
assert_eq!(layout.storage.size, 8);
|
|
assert_eq!(layout.storage.alignment, 8);
|
|
assert_eq!(layout.storage.default, DefaultKind::Null);
|
|
}
|
|
|
|
#[test]
|
|
fn fn_descriptor_bytes_are_independent_of_execution_width_caches() {
|
|
let r = resolve(RegistryDeclarations {
|
|
types: vec![
|
|
builtin(BuiltinId::INT32),
|
|
builtin(BuiltinId::VEC2),
|
|
TypeDecl {
|
|
name: None,
|
|
kind: TypeKind::Fn(Signature {
|
|
parameters: vec![named(1)],
|
|
results: vec![TypeId(0)],
|
|
}),
|
|
},
|
|
],
|
|
..Default::default()
|
|
})
|
|
.unwrap();
|
|
let sections = encode_registry(&r, &mut budget()).unwrap();
|
|
assert_eq!(sections.types,hex("03 00 00 00 00 00 10 00 00 00 00 00 02 00 00 00 04 00 01 00 00 00 01 00 00 00 00 01 00 00 00 00 00 00 00"));
|
|
let callable = r.type_layout(TypeId(2)).unwrap().callable.as_ref().unwrap();
|
|
assert_eq!((callable.parameter_slots, callable.result_slots), (2, 1));
|
|
}
|
|
|
|
#[test]
|
|
fn fn_array_structural_cycles_reject_and_nominal_anchors_terminate() {
|
|
let mut types = vec![
|
|
TypeDecl {
|
|
name: None,
|
|
kind: TypeKind::Fn(Signature { parameters: vec![named(1)], results: vec![] }),
|
|
},
|
|
TypeDecl { name: None, kind: TypeKind::Array(TypeId(0)) },
|
|
];
|
|
assert_eq!(
|
|
resolve(RegistryDeclarations { types: types.clone(), ..Default::default() })
|
|
.unwrap_err()
|
|
.reason,
|
|
LoadReason::StructuralTypeCycle
|
|
);
|
|
types[1].kind = TypeKind::Struct(vec![named(0)]);
|
|
resolve(RegistryDeclarations { types, ..Default::default() }).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn captures_section_has_independent_bytes_and_strict_shape() {
|
|
let r = resolve(RegistryDeclarations {
|
|
types: vec![builtin(BuiltinId::INT32), builtin(BuiltinId::VEC2)],
|
|
functions: vec![FunctionDecl {
|
|
code_len: 2,
|
|
captures: vec![TypeId(1), TypeId(0)],
|
|
..Default::default()
|
|
}],
|
|
..Default::default()
|
|
})
|
|
.unwrap();
|
|
let sections = encode_registry(&r, &mut budget()).unwrap();
|
|
assert_eq!(sections.captures, hex("01 00 00 00 02 00 00 00 01 00 00 00 00 00 00 00"));
|
|
let layout = r.function_layout(FunctionId(0)).unwrap();
|
|
assert_eq!(layout.capture_slots, 3);
|
|
assert_eq!(layout.captures[1].slot_offset, 2);
|
|
for (payload, reason) in [
|
|
(hex("00 00 00 00"), LoadReason::CaptureCount),
|
|
(hex("01 00 00 00 01 00 00 00"), LoadReason::Truncated),
|
|
(hex("01 00 00 00 00 00 00 00 00"), LoadReason::TrailingBytes),
|
|
(hex("01 00 00 00 01 00 00 00 ff ff ff ff"), LoadReason::TypeId),
|
|
] {
|
|
let e = OwnedPbx::parse(&with_section(8, &payload), &mut budget()).unwrap_err();
|
|
assert_eq!(e.reason, reason);
|
|
assert_eq!(e.section, Some(8));
|
|
}
|
|
}
|
|
fn named(id: u32) -> NamedType {
|
|
NamedType { type_id: TypeId(id), name: None }
|
|
}
|
|
fn builtin(id: BuiltinId) -> TypeDecl {
|
|
TypeDecl { name: None, kind: TypeKind::Builtin(id) }
|
|
}
|
|
fn resolve(d: RegistryDeclarations) -> Result<Registry, LoadFailure> {
|
|
Registry::resolve(d, 100, &mut budget())
|
|
}
|
|
fn hex(s: &str) -> Vec<u8> {
|
|
s.split_whitespace().map(|b| u8::from_str_radix(b, 16).unwrap()).collect()
|
|
}
|
|
|
|
// Independently specified PBX, not generated by any production serializer.
|
|
// Header 32 bytes, eight directory entries (96 bytes), payload starts at 128.
|
|
// constants=128/4, functions=132/29, code=161/2, exports=163/4,
|
|
// syscalls=167/4, types=171/10, implementations=181/4. Total=193.
|
|
fn minimal_bytes() -> Vec<u8> {
|
|
hex("
|
|
50 42 58 00 01 00 00 00 08 00 00 00
|
|
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
|
|
00 00 00 00 80 00 00 00 04 00 00 00
|
|
01 00 00 00 84 00 00 00 1d 00 00 00
|
|
02 00 00 00 a1 00 00 00 02 00 00 00
|
|
04 00 00 00 a3 00 00 00 04 00 00 00
|
|
05 00 00 00 a7 00 00 00 04 00 00 00
|
|
06 00 00 00 ab 00 00 00 0a 00 00 00
|
|
07 00 00 00 b5 00 00 00 04 00 00 00
|
|
08 00 00 00 b9 00 00 00 08 00 00 00
|
|
00 00 00 00
|
|
01 00 00 00 00 00 00 00 00 00 00 00 00
|
|
00 00 00 00 02 00 00 00 00 00 00 00 00 00 00 00
|
|
01 00
|
|
00 00 00 00
|
|
00 00 00 00
|
|
01 00 00 00 00 00 13 00 00 00
|
|
00 00 00 00
|
|
01 00 00 00 00 00 00 00")
|
|
}
|
|
fn minimal_registry() -> Registry {
|
|
resolve(RegistryDeclarations {
|
|
types: vec![builtin(BuiltinId::BOOL)],
|
|
functions: vec![FunctionDecl { code_len: 2, ..Default::default() }],
|
|
..Default::default()
|
|
})
|
|
.unwrap()
|
|
}
|
|
fn envelope(types: &[u8], functions: &[u8], implementations: &[u8]) -> Vec<u8> {
|
|
let empty = [0; 4];
|
|
let code = [1, 0];
|
|
let n = u32::from_le_bytes(functions[..4].try_into().unwrap()) as usize;
|
|
let mut captures = vec![0; 4 + 4 * n];
|
|
captures[..4].copy_from_slice(&(n as u32).to_le_bytes());
|
|
encode_envelope(
|
|
&[
|
|
SectionData { kind: 0, bytes: &empty },
|
|
SectionData { kind: 1, bytes: functions },
|
|
SectionData { kind: 2, bytes: &code },
|
|
SectionData { kind: 4, bytes: &empty },
|
|
SectionData { kind: 5, bytes: &empty },
|
|
SectionData { kind: 6, bytes: types },
|
|
SectionData { kind: 7, bytes: implementations },
|
|
SectionData { kind: 8, bytes: &captures },
|
|
],
|
|
&mut budget(),
|
|
)
|
|
.unwrap()
|
|
}
|
|
#[test]
|
|
fn writer_matches_independent_minimal_envelope() {
|
|
let sections = encode_registry(&minimal_registry(), &mut budget()).unwrap();
|
|
let bytes = envelope(§ions.types, §ions.functions, §ions.implementations);
|
|
assert_eq!(bytes, minimal_bytes());
|
|
assert_eq!(bytes.len(), 193);
|
|
let mut b = budget();
|
|
let env = PbxEnvelope::parse(&bytes, &mut b).unwrap();
|
|
assert_eq!(env.section(2).unwrap().offset, 161);
|
|
let registry = env.resolve_registry(&mut b).unwrap();
|
|
assert_eq!(registry.declarations(), minimal_registry().declarations());
|
|
assert_eq!(b.used(LoadResource::TemporaryBytes), 0);
|
|
assert_eq!(registry.declarations().functions[0].max_stack_slots, 0);
|
|
}
|
|
|
|
#[test]
|
|
fn owned_v1_decoder_accepts_independent_bytes_without_publishing_an_image() {
|
|
let mut b = budget();
|
|
let owned = OwnedPbx::parse(&minimal_bytes(), &mut b).unwrap();
|
|
assert_eq!(owned.registry.declarations(), minimal_registry().declarations());
|
|
assert_eq!(owned.code, [1, 0]);
|
|
assert!(owned.constants.is_empty());
|
|
assert!(owned.exports.is_empty());
|
|
assert!(owned.syscalls.is_empty());
|
|
assert!(owned.debug.is_none());
|
|
assert_eq!(b.used(LoadResource::TemporaryBytes), owned.code.capacity() as u64);
|
|
}
|
|
|
|
#[test]
|
|
fn owned_payloads_preserve_utf8_float_bits_names_and_binding_declarations() {
|
|
use prometeu_bytecode::model::{ConstantPoolEntry as K, DebugInfo, Export, SyscallDecl};
|
|
use prometeu_bytecode::SourceSpan;
|
|
let registry = minimal_registry();
|
|
let constants = [
|
|
K::Null,
|
|
K::Int32(i32::MIN),
|
|
K::Int64(i64::MAX),
|
|
K::Float64(f64::from_bits(0x7ff8000000000042)),
|
|
K::Boolean(true),
|
|
K::String("é猫".into()),
|
|
K::String(String::new()),
|
|
];
|
|
let debug = DebugInfo {
|
|
pc_to_span: vec![(0, SourceSpan { file_id: 9, start: 2, end: 7 })],
|
|
function_names: vec![(0, "débug".into())],
|
|
};
|
|
let exports = [Export { func_idx: 0, symbol: "入口".into() }];
|
|
let syscalls = [SyscallDecl {
|
|
module: "system".into(),
|
|
name: "hasCart".into(),
|
|
version: 1,
|
|
arg_slots: 0,
|
|
ret_slots: 1,
|
|
}];
|
|
let bytes = PbxModule {
|
|
registry: ®istry,
|
|
constants: &constants,
|
|
code: &[1, 0],
|
|
debug: Some(&debug),
|
|
exports: &exports,
|
|
syscalls: &syscalls,
|
|
}
|
|
.serialize(&mut budget())
|
|
.unwrap();
|
|
let mut b = budget();
|
|
let module = OwnedPbx::parse(&bytes, &mut b).unwrap();
|
|
assert_eq!(&module.constants[..3], &constants[..3]);
|
|
let K::Float64(value) = module.constants[3] else { panic!() };
|
|
assert_eq!(value.to_bits(), 0x7ff8000000000042);
|
|
assert_eq!(&module.constants[4..], &constants[4..]);
|
|
assert_eq!(module.debug.as_ref(), Some(&debug));
|
|
assert_eq!(module.exports, exports);
|
|
assert_eq!(module.syscalls, syscalls);
|
|
assert_eq!(b.used(LoadResource::ConstantEntries), 7);
|
|
assert_eq!(b.used(LoadResource::ConstantStringBytes), 5);
|
|
drop(bytes);
|
|
assert_eq!(module.constants[5], K::String("é猫".into()));
|
|
}
|
|
|
|
#[test]
|
|
fn owned_payload_refusal_rolls_back_all_ownership_and_preserves_prior_budget() {
|
|
let bytes = minimal_bytes();
|
|
let mut full = budget();
|
|
OwnedPbx::parse(&bytes, &mut full).unwrap();
|
|
let limits = LoadLimits { work: full.used(LoadResource::Work) - 1, ..Default::default() };
|
|
let mut b = LoadBudget::new(limits);
|
|
b.charge(LoadResource::TemporaryBytes, 7).unwrap();
|
|
b.charge(LoadResource::RegistryBytes, 3).unwrap();
|
|
let failure = OwnedPbx::parse(&bytes, &mut b).unwrap_err();
|
|
assert_eq!(failure.resource, Some(LoadResource::Work));
|
|
assert_eq!(failure.section, Some(2));
|
|
assert_eq!(b.used(LoadResource::TemporaryBytes), 7);
|
|
assert_eq!(b.used(LoadResource::RegistryBytes), 3);
|
|
assert_eq!(b.used(LoadResource::Types), 0);
|
|
assert_eq!(b.used(LoadResource::ConstantEntries), 0);
|
|
let limits = LoadLimits { temporary_bytes: 1, ..Default::default() };
|
|
let mut b = LoadBudget::new(limits);
|
|
assert_eq!(
|
|
OwnedPbx::parse(&bytes, &mut b).unwrap_err().resource,
|
|
Some(LoadResource::TemporaryBytes)
|
|
);
|
|
assert_eq!(b.used(LoadResource::RegistryBytes), 0);
|
|
assert_eq!(b.used(LoadResource::TemporaryBytes), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn complete_module_writer_matches_independent_minimal_bytes_and_refunds_scratch() {
|
|
let registry = minimal_registry();
|
|
let module = PbxModule {
|
|
registry: ®istry,
|
|
constants: &[],
|
|
code: &[1, 0],
|
|
debug: None,
|
|
exports: &[],
|
|
syscalls: &[],
|
|
};
|
|
let mut b = budget();
|
|
b.charge(LoadResource::TemporaryBytes, 7).unwrap();
|
|
let bytes = module.serialize(&mut b).unwrap();
|
|
assert_eq!(bytes, minimal_bytes());
|
|
assert_eq!(b.used(LoadResource::TemporaryBytes), 7 + bytes.capacity() as u64);
|
|
assert_eq!(b.used(LoadResource::RegistryBytes), 0);
|
|
assert_eq!(b.used(LoadResource::ConstantEntries), 0);
|
|
ParsedPbx::parse(&bytes, &mut budget()).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn complete_module_writer_preserves_non_registry_encodings() {
|
|
use prometeu_bytecode::model::{ConstantPoolEntry as K, DebugInfo, Export, SyscallDecl};
|
|
use prometeu_bytecode::SourceSpan;
|
|
let registry = minimal_registry();
|
|
let constants = [
|
|
K::Null,
|
|
K::Int64(-1),
|
|
K::Float64(f64::from_bits(0x7ff8000000001234)),
|
|
K::Boolean(true),
|
|
K::String("é".into()),
|
|
K::Int32(-2),
|
|
K::String(String::new()),
|
|
];
|
|
let debug = DebugInfo {
|
|
pc_to_span: vec![(0, SourceSpan { file_id: 7, start: 2, end: 9 })],
|
|
function_names: vec![(0, String::new())],
|
|
};
|
|
let exports = [Export { symbol: "boot".into(), func_idx: 0 }];
|
|
let syscalls = [SyscallDecl {
|
|
module: "m".into(),
|
|
name: "n".into(),
|
|
version: 3,
|
|
arg_slots: 2,
|
|
ret_slots: 1,
|
|
}];
|
|
let module = PbxModule {
|
|
registry: ®istry,
|
|
constants: &constants,
|
|
code: &[1, 0],
|
|
debug: Some(&debug),
|
|
exports: &exports,
|
|
syscalls: &syscalls,
|
|
};
|
|
let bytes = module.serialize(&mut budget()).unwrap();
|
|
let parsed = ParsedPbx::parse(&bytes, &mut budget()).unwrap();
|
|
assert_eq!(
|
|
parsed.section(0).unwrap().bytes,
|
|
hex("07 00 00 00 00
|
|
01 ff ff ff ff ff ff ff ff
|
|
02 34 12 00 00 00 00 f8 7f
|
|
03 01 04 02 00 00 00 c3 a9 05 fe ff ff ff 04 00 00 00 00")
|
|
);
|
|
assert_eq!(
|
|
parsed.section(3).unwrap().bytes,
|
|
hex("01 00 00 00 00 00 00 00
|
|
07 00 00 00 02 00 00 00 09 00 00 00 01 00 00 00 00 00 00 00 00 00 00 00")
|
|
);
|
|
assert_eq!(
|
|
parsed.section(4).unwrap().bytes,
|
|
hex("01 00 00 00 00 00 00 00 04 00 00 00 62 6f 6f 74")
|
|
);
|
|
assert_eq!(
|
|
parsed.section(5).unwrap().bytes,
|
|
hex("01 00 00 00 01 00 6d 01 00 6e 03 00 02 00 01 00")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn complete_module_writer_rejects_invalid_payload_records_without_retaining_scratch() {
|
|
use prometeu_bytecode::model::{DebugInfo, Export, SyscallDecl};
|
|
use prometeu_bytecode::SourceSpan;
|
|
let registry = minimal_registry();
|
|
let bad_export = [Export { symbol: "bad".into(), func_idx: u32::MAX }];
|
|
let syscall = SyscallDecl { module: "m".into(), name: "n".into(), ..Default::default() };
|
|
let duplicates = [syscall.clone(), syscall];
|
|
let bad_debug = DebugInfo {
|
|
pc_to_span: vec![(2, SourceSpan { file_id: 0, start: 0, end: 1 })],
|
|
..Default::default()
|
|
};
|
|
for (exports, syscalls, debug, reason) in [
|
|
(&bad_export[..], &[][..], None, LoadReason::FunctionId),
|
|
(&[][..], &duplicates[..], None, LoadReason::DuplicateSyscall),
|
|
(&[][..], &[][..], Some(&bad_debug), LoadReason::DebugRange),
|
|
] {
|
|
let mut b = budget();
|
|
b.charge(LoadResource::TemporaryBytes, 7).unwrap();
|
|
let e = PbxModule {
|
|
registry: ®istry,
|
|
constants: &[],
|
|
code: &[1, 0],
|
|
debug,
|
|
exports,
|
|
syscalls,
|
|
}
|
|
.serialize(&mut b)
|
|
.unwrap_err();
|
|
assert_eq!(e.reason, reason);
|
|
assert_eq!(b.used(LoadResource::TemporaryBytes), 7);
|
|
assert!(b.used(LoadResource::Work) > 0);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn complete_module_writer_checks_constant_quotas_before_payload_allocation() {
|
|
use prometeu_bytecode::model::ConstantPoolEntry as K;
|
|
let registry = minimal_registry();
|
|
let constants = [K::String("abc".into()), K::String("abc".into())];
|
|
let module = PbxModule {
|
|
registry: ®istry,
|
|
constants: &constants,
|
|
code: &[1, 0],
|
|
debug: None,
|
|
exports: &[],
|
|
syscalls: &[],
|
|
};
|
|
for (resource, limit) in [
|
|
(LoadResource::ConstantEntries, 1),
|
|
(LoadResource::ConstantStringBytes, 5),
|
|
(LoadResource::TemporaryBytes, 1),
|
|
] {
|
|
let mut limits = LoadLimits::default();
|
|
match resource {
|
|
LoadResource::ConstantEntries => limits.constant_entries = limit,
|
|
LoadResource::ConstantStringBytes => limits.constant_string_bytes = limit,
|
|
LoadResource::TemporaryBytes => limits.temporary_bytes = limit,
|
|
_ => unreachable!(),
|
|
}
|
|
let mut b = LoadBudget::new(limits);
|
|
let error = module.serialize(&mut b).unwrap_err();
|
|
assert_eq!(error.code, LoadCode::ResourceLimit);
|
|
assert_eq!(error.resource, Some(resource));
|
|
assert_eq!(b.used(LoadResource::TemporaryBytes), 0);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn complete_module_writer_rejects_code_range_mismatch() {
|
|
let registry = minimal_registry();
|
|
let e = PbxModule {
|
|
registry: ®istry,
|
|
constants: &[],
|
|
code: &[],
|
|
debug: None,
|
|
exports: &[],
|
|
syscalls: &[],
|
|
}
|
|
.serialize(&mut budget())
|
|
.unwrap_err();
|
|
assert_eq!((e.code, e.reason), (LoadCode::InvalidCode, LoadReason::CodeRange));
|
|
assert_eq!((e.function, e.pc), (Some(0), Some(0)));
|
|
}
|
|
#[test]
|
|
fn representative_records_match_fixed_bytes_and_preserve_names_without_debug() {
|
|
let types = hex("
|
|
04 00 00 00
|
|
00 00 13 00 00 00
|
|
01 01 00 00 00 00 01 00 00 00 00 00 00 00 00
|
|
02 00 01 00 00 00
|
|
03 00 01 00 00 00 01 01 00 00 00 6d
|
|
01 00 00 00 00 00 00 00 01 01 00 00 00 70
|
|
01 00 00 00 00 00 00 00");
|
|
let functions = hex("
|
|
01 00 00 00 01 01 00 00 00 66
|
|
02 00 00 00 01 00 00 00 00 00 00 00 00 01 01 00 00 00 70
|
|
01 00 00 00 00 00 00 00
|
|
00 00 00 00 02 00 00 00 00 00 00 00 01 00 00 00");
|
|
let implementations = hex("01 00 00 00 01 00 00 00 03 00 00 00 01 00 00 00 00 00 00 00");
|
|
let bytes = envelope(&types, &functions, &implementations);
|
|
let mut b = budget();
|
|
let env = PbxEnvelope::parse(&bytes, &mut b).unwrap();
|
|
assert!(env.section(3).is_none());
|
|
let r = env.resolve_registry(&mut b).unwrap();
|
|
assert_eq!(r.declarations().types[0].name, None);
|
|
assert_eq!(r.declarations().types[1].name, Some(String::new()));
|
|
assert_eq!(r.declarations().functions[0].signature.parameters[1].name.as_deref(), Some("p"));
|
|
assert_eq!(r.implementation(TypeId(1), TypeId(3)), Some(ImplementationId(0)));
|
|
assert_eq!(r.type_layout(TypeId(2)).unwrap().storage.size, 8);
|
|
let encoded = encode_registry(&r, &mut budget()).unwrap();
|
|
assert_eq!(encoded.types, types);
|
|
assert_eq!(encoded.functions, functions);
|
|
assert_eq!(encoded.implementations, implementations);
|
|
}
|
|
#[test]
|
|
fn every_truncated_envelope_is_rejected_without_panic() {
|
|
let bytes = minimal_bytes();
|
|
for n in 0..bytes.len() {
|
|
let mut b = budget();
|
|
assert!(PbxEnvelope::parse(&bytes[..n], &mut b).is_err(), "prefix {n}");
|
|
}
|
|
}
|
|
#[test]
|
|
fn envelope_mutations_have_typed_reasons() {
|
|
for (offset, value, code, reason) in [
|
|
(0, 0, LoadCode::InvalidFormat, LoadReason::Magic),
|
|
(4, 0, LoadCode::UnsupportedFormat, LoadReason::Version),
|
|
(6, 1, LoadCode::InvalidFormat, LoadReason::Endianness),
|
|
(7, 1, LoadCode::InvalidFormat, LoadReason::Reserved),
|
|
(31, 1, LoadCode::InvalidFormat, LoadReason::Reserved),
|
|
(32, 9, LoadCode::UnsupportedFormat, LoadReason::SectionKind),
|
|
(44, 0, LoadCode::InvalidFormat, LoadReason::DuplicateSection),
|
|
(36, 0, LoadCode::InvalidFormat, LoadReason::Overlap),
|
|
(48, 128, LoadCode::InvalidFormat, LoadReason::Overlap),
|
|
] {
|
|
let mut bytes = minimal_bytes();
|
|
bytes[offset] = value;
|
|
let err = PbxEnvelope::parse(&bytes, &mut budget()).unwrap_err();
|
|
assert_eq!((err.code, err.reason), (code, reason), "offset {offset}");
|
|
}
|
|
}
|
|
#[test]
|
|
fn mandatory_empty_sections_are_required() {
|
|
let mut bytes = minimal_bytes();
|
|
bytes[32] = 3; // replaces constants with optional debug
|
|
let err = PbxEnvelope::parse(&bytes, &mut budget()).unwrap_err();
|
|
assert_eq!(err.reason, LoadReason::MissingSection);
|
|
assert_eq!(err.section, Some(0));
|
|
let mut bytes = minimal_bytes();
|
|
bytes[116] = 3; // captures replaced by optional debug
|
|
let err = PbxEnvelope::parse(&bytes, &mut budget()).unwrap_err();
|
|
assert_eq!(err.reason, LoadReason::MissingSection);
|
|
assert_eq!(err.section, Some(8));
|
|
let mut bytes = minimal_bytes();
|
|
bytes[104] = 8; // duplicate captures directory entry
|
|
let err = PbxEnvelope::parse(&bytes, &mut budget()).unwrap_err();
|
|
assert_eq!(err.reason, LoadReason::DuplicateSection);
|
|
assert_eq!(err.section, Some(8));
|
|
}
|
|
#[test]
|
|
fn record_flags_utf8_trailing_bytes_and_unknown_categories_fail() {
|
|
let valid = minimal_bytes();
|
|
let mut b = budget();
|
|
let env = PbxEnvelope::parse(&valid, &mut b).unwrap();
|
|
let functions = env.section(1).unwrap().bytes;
|
|
let implementations = env.section(7).unwrap().bytes;
|
|
for (types, reason) in [
|
|
(hex("01 00 00 00 00 02 13 00 00 00"), LoadReason::InvalidFlag),
|
|
(hex("01 00 00 00 05 00 13 00 00 00"), LoadReason::Category),
|
|
(hex("01 00 00 00 00 01 01 00 00 00 ff 13 00 00 00"), LoadReason::Utf8),
|
|
(hex("01 00 00 00 00 00 13 00 00 00 ff"), LoadReason::TrailingBytes),
|
|
(hex("01 00 00 00 00 00 00 01 00 00"), LoadReason::Builtin),
|
|
] {
|
|
let bytes = envelope(&types, functions, implementations);
|
|
let mut b = budget();
|
|
let env = PbxEnvelope::parse(&bytes, &mut b).unwrap();
|
|
let err = env.resolve_registry(&mut b).unwrap_err();
|
|
assert_eq!(err.reason, reason);
|
|
assert_eq!(b.used(LoadResource::RegistryBytes), 0);
|
|
assert_eq!(b.used(LoadResource::TemporaryBytes), 0);
|
|
}
|
|
}
|
|
#[test]
|
|
fn oversized_counts_fail_before_dependent_allocation() {
|
|
let bytes = envelope(&[255; 4], &[0; 4], &[0; 4]);
|
|
let mut b = budget();
|
|
let env = PbxEnvelope::parse(&bytes, &mut b).unwrap();
|
|
let err = env.resolve_registry(&mut b).unwrap_err();
|
|
assert_eq!(err.resource, Some(LoadResource::Types));
|
|
assert_eq!(b.used(LoadResource::TemporaryBytes), 0);
|
|
}
|
|
#[test]
|
|
fn logical_scalar_layout_and_empty_nominal_identity() {
|
|
let d = RegistryDeclarations {
|
|
types: vec![
|
|
builtin(BuiltinId::BOOL),
|
|
builtin(BuiltinId::INT32),
|
|
TypeDecl { name: None, kind: TypeKind::Struct(vec![named(0), named(1), named(0)]) },
|
|
TypeDecl { name: None, kind: TypeKind::Struct(vec![]) },
|
|
TypeDecl { name: None, kind: TypeKind::Struct(vec![]) },
|
|
TypeDecl { name: None, kind: TypeKind::Array(TypeId(2)) },
|
|
],
|
|
..Default::default()
|
|
};
|
|
let r = resolve(d).unwrap();
|
|
let s = r.type_layout(TypeId(2)).unwrap();
|
|
assert_eq!(s.storage.size, 8);
|
|
let p = s.instance.as_ref().unwrap();
|
|
assert_eq!((p.size, p.alignment), (12, 4));
|
|
assert_eq!(p.fields.iter().map(|f| f.offset).collect::<Vec<_>>(), vec![0, 4, 8]);
|
|
assert!(p.owned_fields.is_empty());
|
|
for id in [3, 4] {
|
|
let l = r.type_layout(TypeId(id)).unwrap().instance.as_ref().unwrap();
|
|
assert_eq!((l.size, l.alignment), (0, 1));
|
|
}
|
|
assert_eq!(r.type_layout(TypeId(5)).unwrap().storage.size, 8);
|
|
assert_eq!(r.declarations().types.len(), 6);
|
|
}
|
|
#[test]
|
|
fn nominal_recursion_and_forward_references_terminate() {
|
|
let r = resolve(RegistryDeclarations {
|
|
types: vec![
|
|
TypeDecl { name: None, kind: TypeKind::Struct(vec![named(0), named(1)]) },
|
|
TypeDecl { name: None, kind: TypeKind::Array(TypeId(0)) },
|
|
],
|
|
..Default::default()
|
|
})
|
|
.unwrap();
|
|
let layout = r.type_layout(TypeId(0)).unwrap().instance.as_ref().unwrap();
|
|
assert_eq!(layout.size, 16);
|
|
assert_eq!(layout.owned_fields.len(), 2);
|
|
}
|
|
#[test]
|
|
fn duplicate_imports_and_arrays_and_structural_cycles_fail() {
|
|
let cases = [
|
|
(vec![builtin(BuiltinId::BOOL), builtin(BuiltinId::BOOL)], LoadReason::DuplicateBuiltin),
|
|
(
|
|
vec![
|
|
builtin(BuiltinId::BOOL),
|
|
TypeDecl { name: None, kind: TypeKind::Array(TypeId(0)) },
|
|
TypeDecl { name: None, kind: TypeKind::Array(TypeId(0)) },
|
|
],
|
|
LoadReason::DuplicateArray,
|
|
),
|
|
(vec![TypeDecl { name: None, kind: TypeKind::Array(TypeId(0)) }], LoadReason::ArrayCycle),
|
|
(
|
|
vec![
|
|
TypeDecl { name: None, kind: TypeKind::Array(TypeId(1)) },
|
|
TypeDecl { name: None, kind: TypeKind::Array(TypeId(0)) },
|
|
],
|
|
LoadReason::ArrayCycle,
|
|
),
|
|
];
|
|
for (types, reason) in cases {
|
|
assert_eq!(
|
|
resolve(RegistryDeclarations { types, ..Default::default() }).unwrap_err().reason,
|
|
reason
|
|
);
|
|
}
|
|
}
|
|
#[test]
|
|
fn long_array_chain_uses_bounded_iteration() {
|
|
let mut types: Vec<_> = (0..10_000)
|
|
.map(|i| TypeDecl { name: None, kind: TypeKind::Array(TypeId(i + 1)) })
|
|
.collect();
|
|
types.push(builtin(BuiltinId::INT32));
|
|
assert!(resolve(RegistryDeclarations { types, ..Default::default() }).is_ok());
|
|
}
|
|
#[test]
|
|
fn invalid_references_are_not_indexed() {
|
|
let d = RegistryDeclarations {
|
|
types: vec![TypeDecl { name: None, kind: TypeKind::Struct(vec![named(u32::MAX)]) }],
|
|
..Default::default()
|
|
};
|
|
let e = resolve(d).unwrap_err();
|
|
assert_eq!(e.code, LoadCode::InvalidReference);
|
|
assert_eq!(e.member, Some(0));
|
|
}
|
|
#[test]
|
|
fn all_builtin_widths_native_layout_and_unknown_imports() {
|
|
for (id, size, alignment, slots) in [
|
|
(1, 4, 4, 1),
|
|
(2, 16, 8, 2),
|
|
(3, 24, 8, 3),
|
|
(0x10, 4, 4, 1),
|
|
(0x11, 8, 8, 1),
|
|
(0x12, 8, 8, 1),
|
|
(0x13, 1, 1, 1),
|
|
] {
|
|
let l = BuiltinId(id).layout().unwrap();
|
|
assert_eq!((l.size, l.alignment, l.slots), (size, alignment, slots));
|
|
assert!(!l.nullable());
|
|
}
|
|
let s = BuiltinId::STRING.layout().unwrap();
|
|
assert_eq!((s.size, s.alignment), (size_of::<StringSlot>(), align_of::<StringSlot>()));
|
|
assert!(s.nullable());
|
|
let d = BuiltinId::DYNAMIC.layout().unwrap();
|
|
assert_eq!((d.size, d.alignment), (size_of::<DynamicSlot>(), align_of::<DynamicSlot>()));
|
|
for id in [0, 4, 0x100, 0x101, 0x102, u32::MAX] {
|
|
assert_eq!(BuiltinId(id).layout().unwrap_err().reason, LoadReason::Builtin);
|
|
}
|
|
}
|
|
fn implemented() -> RegistryDeclarations {
|
|
RegistryDeclarations {
|
|
types: vec![
|
|
builtin(BuiltinId::VEC2),
|
|
TypeDecl { name: None, kind: TypeKind::Struct(vec![]) },
|
|
TypeDecl {
|
|
name: None,
|
|
kind: TypeKind::Trait(vec![MethodDecl {
|
|
name: None,
|
|
signature: Signature { parameters: vec![named(0)], results: vec![TypeId(0)] },
|
|
}]),
|
|
},
|
|
],
|
|
functions: vec![FunctionDecl {
|
|
signature: Signature { parameters: vec![named(1), named(0)], results: vec![TypeId(0)] },
|
|
code_len: 2,
|
|
max_stack_slots: 2,
|
|
..Default::default()
|
|
}],
|
|
implementations: vec![ImplementationDecl {
|
|
owner: TypeId(1),
|
|
trait_id: TypeId(2),
|
|
methods: vec![FunctionId(0)],
|
|
}],
|
|
}
|
|
}
|
|
#[test]
|
|
fn multi_slot_signatures_derive_counts_and_validate_exact_trait_pair() {
|
|
let r = resolve(implemented()).unwrap();
|
|
assert_eq!(
|
|
r.function_layout(FunctionId(0)),
|
|
Some(&FunctionLayout {
|
|
parameter_slots: 3,
|
|
result_slots: 2,
|
|
capture_slots: 0,
|
|
captures: vec![]
|
|
})
|
|
);
|
|
let mut d = implemented();
|
|
d.functions[0].signature.parameters.swap(0, 1);
|
|
assert_eq!(resolve(d).unwrap_err().reason, LoadReason::Signature);
|
|
let mut d = implemented();
|
|
d.functions[0].signature.results.clear();
|
|
assert_eq!(resolve(d).unwrap_err().reason, LoadReason::Signature);
|
|
let mut d = implemented();
|
|
d.implementations.push(d.implementations[0].clone());
|
|
assert_eq!(resolve(d).unwrap_err().reason, LoadReason::DuplicateImplementation);
|
|
let mut d = implemented();
|
|
d.implementations[0].methods.clear();
|
|
assert_eq!(resolve(d).unwrap_err().reason, LoadReason::MethodCount);
|
|
let mut d = implemented();
|
|
d.implementations[0].owner = TypeId(0);
|
|
assert_eq!(resolve(d).unwrap_err().reason, LoadReason::OwnerCategory);
|
|
}
|
|
#[test]
|
|
fn literal_zero_max_stack_is_preserved_and_frame_limits_are_not_truncated() {
|
|
let mut d = implemented();
|
|
d.functions[0].max_stack_slots = 0;
|
|
assert!(resolve(d).is_ok());
|
|
let mut d = implemented();
|
|
d.functions[0].local_slots = 65_536;
|
|
assert_eq!(resolve(d).unwrap_err().reason, LoadReason::FrameSlots);
|
|
let mut d = implemented();
|
|
d.functions[0].code_offset = u32::MAX;
|
|
assert_eq!(resolve(d).unwrap_err().reason, LoadReason::CodeRange);
|
|
let mut d = implemented();
|
|
d.functions.push(d.functions[0].clone());
|
|
assert_eq!(resolve(d).unwrap_err().reason, LoadReason::CodeRange);
|
|
}
|
|
#[test]
|
|
fn work_retained_and_temporary_limits_refuse_before_publication() {
|
|
for limits in [
|
|
LoadLimits { work: 1, ..Default::default() },
|
|
LoadLimits { registry_bytes: 1, ..Default::default() },
|
|
LoadLimits { temporary_bytes: 1, ..Default::default() },
|
|
] {
|
|
let mut b = LoadBudget::new(limits);
|
|
let e = Registry::resolve(implemented(), 100, &mut b).unwrap_err();
|
|
assert_eq!(e.code, LoadCode::ResourceLimit);
|
|
assert_eq!(b.used(LoadResource::RegistryBytes), 0);
|
|
assert_eq!(b.used(LoadResource::TemporaryBytes), 0);
|
|
}
|
|
}
|
|
#[test]
|
|
fn budget_boundaries_are_transactional_and_product_ceiling_cannot_be_raised() {
|
|
let mut b = LoadBudget::new(LoadLimits { temporary_bytes: 8, ..Default::default() });
|
|
b.charge(LoadResource::TemporaryBytes, 8).unwrap();
|
|
assert!(b.charge(LoadResource::TemporaryBytes, 1).is_err());
|
|
assert_eq!(b.used(LoadResource::TemporaryBytes), 8);
|
|
b.refund(LoadResource::TemporaryBytes, 8);
|
|
assert_eq!(b.used(LoadResource::TemporaryBytes), 0);
|
|
let b = LoadBudget::new(LoadLimits { pbx_bytes: u64::MAX, ..Default::default() });
|
|
assert_eq!(b.limit(LoadResource::PbxBytes), 64 * 1_048_576);
|
|
}
|
|
#[test]
|
|
fn name_limits_include_aggregate_and_empty_is_not_absent() {
|
|
let mut d = implemented();
|
|
d.types[0].name = Some("x".repeat(4097));
|
|
assert_eq!(resolve(d).unwrap_err().resource, Some(LoadResource::NameBytes));
|
|
let mut d = implemented();
|
|
d.types[0].name = Some("ab".into());
|
|
d.types[1].name = Some("cd".into());
|
|
let mut b = LoadBudget::new(LoadLimits { name_bytes: 3, ..Default::default() });
|
|
assert_eq!(
|
|
Registry::resolve(d, 100, &mut b).unwrap_err().resource,
|
|
Some(LoadResource::NameBytes)
|
|
);
|
|
}
|
|
|
|
fn with_section(kind: u32, payload: &[u8]) -> Vec<u8> {
|
|
let bytes = minimal_bytes();
|
|
let mut b = budget();
|
|
let env = PbxEnvelope::parse(&bytes, &mut b).unwrap();
|
|
let mut sections = Vec::new();
|
|
for k in 0..9 {
|
|
if k == kind {
|
|
sections.push(SectionData { kind: k, bytes: payload });
|
|
} else if let Some(section) = env.section(k) {
|
|
sections.push(SectionData { kind: k, bytes: section.bytes });
|
|
}
|
|
}
|
|
encode_envelope(§ions, &mut budget()).unwrap()
|
|
}
|
|
#[test]
|
|
fn full_pbx_validation_accepts_independent_minimal_fixture() {
|
|
let bytes = minimal_bytes();
|
|
let mut b = budget();
|
|
let parsed = ParsedPbx::parse(&bytes, &mut b).unwrap();
|
|
assert_eq!(parsed.encode(&mut budget()).unwrap(), bytes);
|
|
assert_eq!(parsed.registry().declarations(), minimal_registry().declarations());
|
|
assert_eq!(b.used(LoadResource::TemporaryBytes), 0);
|
|
}
|
|
#[test]
|
|
fn constants_are_strict_and_validate_every_tag_without_lossy_utf8() {
|
|
let constants=hex("06 00 00 00 00 01 ff ff ff ff ff ff ff ff 02 00 00 00 00 00 00 00 00 03 01 04 03 00 00 00 61 62 63 05 ff ff ff ff");
|
|
let bytes = with_section(0, &constants);
|
|
let mut b = budget();
|
|
let parsed = ParsedPbx::parse(&bytes, &mut b).unwrap();
|
|
assert_eq!(parsed.section(0).unwrap().bytes, constants);
|
|
assert_eq!(b.used(LoadResource::ConstantEntries), 6);
|
|
assert_eq!(b.used(LoadResource::ConstantStringBytes), 3);
|
|
for (cp, reason) in [
|
|
(hex("01 00 00 00 03 02"), LoadReason::InvalidFlag),
|
|
(hex("01 00 00 00 04 01 00 00 00 ff"), LoadReason::Utf8),
|
|
(hex("01 00 00 00 06"), LoadReason::ConstantTag),
|
|
(hex("01 00 00 00 01 ff"), LoadReason::Truncated),
|
|
(hex("00 00 00 00 ff"), LoadReason::TrailingBytes),
|
|
] {
|
|
let bytes = with_section(0, &cp);
|
|
let mut b = budget();
|
|
let e = ParsedPbx::parse(&bytes, &mut b).unwrap_err();
|
|
assert_eq!(e.reason, reason);
|
|
assert_eq!(e.section, Some(0));
|
|
assert_eq!(b.used(LoadResource::RegistryBytes), 0);
|
|
}
|
|
}
|
|
#[test]
|
|
fn constant_string_limits_are_checked_before_materialization() {
|
|
let bytes = with_section(0, &hex("01 00 00 00 04 03 00 00 00 61 62 63"));
|
|
for limits in [
|
|
LoadLimits { individual_string_bytes: 2, ..Default::default() },
|
|
LoadLimits { constant_string_bytes: 2, ..Default::default() },
|
|
LoadLimits { constant_entries: 0, ..Default::default() },
|
|
] {
|
|
let mut b = LoadBudget::new(limits);
|
|
let e = ParsedPbx::parse(&bytes, &mut b).unwrap_err();
|
|
assert_eq!(e.code, LoadCode::ResourceLimit);
|
|
assert_eq!(b.used(LoadResource::ConstantStringBytes), 0);
|
|
assert_eq!(b.used(LoadResource::RegistryBytes), 0);
|
|
}
|
|
}
|
|
#[test]
|
|
fn export_and_debug_references_are_checked_and_table_tails_rejected() {
|
|
let export = hex("01 00 00 00 00 00 00 00 04 00 00 00 6d 61 69 6e");
|
|
assert!(ParsedPbx::parse(&with_section(4, &export), &mut budget()).is_ok());
|
|
let mut bad = export;
|
|
bad[4] = 1;
|
|
let e = ParsedPbx::parse(&with_section(4, &bad), &mut budget()).unwrap_err();
|
|
assert_eq!(e.code, LoadCode::InvalidReference);
|
|
assert_eq!(e.referenced_id, Some(1));
|
|
// One pc/span record; one function name. These are independent of signature names.
|
|
let debug=hex("01 00 00 00 00 00 00 00 07 00 00 00 0a 00 00 00 0c 00 00 00 01 00 00 00 00 00 00 00 01 00 00 00 66");
|
|
let bytes = with_section(3, &debug);
|
|
assert!(ParsedPbx::parse(&bytes, &mut budget()).is_ok());
|
|
let mut bad = debug;
|
|
bad[4] = 2;
|
|
assert_eq!(
|
|
ParsedPbx::parse(&with_section(3, &bad), &mut budget()).unwrap_err().reason,
|
|
LoadReason::DebugRange
|
|
);
|
|
for kind in [3, 4, 5] {
|
|
let payload =
|
|
if kind == 3 { hex("00 00 00 00 00 00 00 00 ff") } else { hex("00 00 00 00 ff") };
|
|
assert_eq!(
|
|
ParsedPbx::parse(&with_section(kind, &payload), &mut budget()).unwrap_err().reason,
|
|
LoadReason::TrailingBytes
|
|
);
|
|
}
|
|
}
|
|
#[test]
|
|
fn syscall_identity_validation_keeps_versions_distinct_and_rejects_duplicates() {
|
|
// module m, name n, version 1, zero arguments/results.
|
|
let entry = hex("01 00 6d 01 00 6e 01 00 00 00 00 00");
|
|
let mut payload = vec![2, 0, 0, 0];
|
|
payload.extend_from_slice(&entry);
|
|
payload.extend_from_slice(&entry);
|
|
let e = ParsedPbx::parse(&with_section(5, &payload), &mut budget()).unwrap_err();
|
|
assert_eq!((e.reason, e.section, e.record), (LoadReason::DuplicateSyscall, Some(5), Some(1)));
|
|
payload[22] = 2; // version in second 12-byte entry
|
|
let bytes = with_section(5, &payload);
|
|
let mut b = budget();
|
|
assert!(ParsedPbx::parse(&bytes, &mut b).is_ok());
|
|
assert_eq!(b.used(LoadResource::TemporaryBytes), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn array_stride_uses_stored_element_layout_and_defaults_are_typed() {
|
|
use prometeu_bytecode::Value;
|
|
let registry = resolve(RegistryDeclarations {
|
|
types: vec![
|
|
builtin(BuiltinId::INT32),
|
|
builtin(BuiltinId::BOOL),
|
|
builtin(BuiltinId::VEC2),
|
|
TypeDecl { name: None, kind: TypeKind::Struct(vec![named(0), named(1)]) },
|
|
TypeDecl { name: None, kind: TypeKind::Array(TypeId(0)) },
|
|
TypeDecl { name: None, kind: TypeKind::Array(TypeId(1)) },
|
|
TypeDecl { name: None, kind: TypeKind::Array(TypeId(2)) },
|
|
TypeDecl { name: None, kind: TypeKind::Array(TypeId(3)) },
|
|
TypeDecl { name: None, kind: TypeKind::Array(TypeId(4)) },
|
|
],
|
|
..Default::default()
|
|
})
|
|
.unwrap();
|
|
for (id, stride, alignment) in [(4, 4, 4), (5, 1, 1), (6, 16, 8), (7, 8, 8), (8, 8, 8)] {
|
|
let a = registry.type_layout(TypeId(id)).unwrap().array.unwrap();
|
|
assert_eq!((a.stride, a.element_alignment), (stride, alignment));
|
|
}
|
|
assert!(matches!(BuiltinId::INT32.layout().unwrap().default_values(), [Value::Int32(0)]));
|
|
assert!(matches!(BuiltinId::BOOL.layout().unwrap().default_values(), [Value::Boolean(false)]));
|
|
assert!(matches!(BuiltinId::COLOR.layout().unwrap().default_values(), [Value::Int64(0)]));
|
|
assert!(matches!(BuiltinId::STRING.layout().unwrap().default_values(), [Value::Null]));
|
|
assert!(matches!(
|
|
BuiltinId::DYNAMIC.layout().unwrap().default_values(),
|
|
[Value::Null, Value::Null]
|
|
));
|
|
for value in BuiltinId::VEC2.layout().unwrap().default_values() {
|
|
let Value::Float(value) = value else { panic!("expected float default") };
|
|
assert_eq!(value.to_bits(), 0);
|
|
}
|
|
assert_eq!(registry.type_layout(TypeId(3)).unwrap().storage.default_values(), &[Value::Null]);
|
|
}
|
|
|
|
/// Run explicitly in release mode; records a map-only comparison, not VM/GC throughput.
|
|
#[test]
|
|
#[ignore = "explicit layout measurement; not a timing assertion"]
|
|
fn reference_map_probe() {
|
|
use std::hint::black_box;
|
|
use std::time::Instant;
|
|
for period in [1, 16, 256] {
|
|
let d = RegistryDeclarations {
|
|
types: vec![
|
|
builtin(BuiltinId::INT64),
|
|
TypeDecl { name: None, kind: TypeKind::Struct(vec![]) },
|
|
TypeDecl {
|
|
name: None,
|
|
kind: TypeKind::Struct(
|
|
(0..4096).map(|i| named(if i % period == 0 { 1 } else { 0 })).collect(),
|
|
),
|
|
},
|
|
],
|
|
..Default::default()
|
|
};
|
|
let mut b = budget();
|
|
let load_start = Instant::now();
|
|
let r = Registry::resolve(d, 0, &mut b).unwrap();
|
|
let load_ns = load_start.elapsed().as_nanos();
|
|
let layout = r.type_layout(TypeId(2)).unwrap().instance.as_ref().unwrap();
|
|
let mut bitmap = vec![0u64; 64];
|
|
for field in &layout.owned_fields {
|
|
let bit = field.offset / 8;
|
|
bitmap[bit / 64] |= 1u64 << (bit % 64);
|
|
}
|
|
let runs = 10_000;
|
|
let start = Instant::now();
|
|
let mut list_checksum = 0usize;
|
|
for _ in 0..runs {
|
|
for field in black_box(&layout.owned_fields) {
|
|
list_checksum = list_checksum.wrapping_add(field.offset);
|
|
}
|
|
}
|
|
black_box(list_checksum);
|
|
let list_ns = start.elapsed().as_nanos();
|
|
let start = Instant::now();
|
|
let mut bitmap_checksum = 0usize;
|
|
for _ in 0..runs {
|
|
for (word_index, &word) in black_box(&bitmap).iter().enumerate() {
|
|
let mut word = word;
|
|
while word != 0 {
|
|
bitmap_checksum = bitmap_checksum
|
|
.wrapping_add((word_index * 64 + word.trailing_zeros() as usize) * 8);
|
|
word &= word - 1;
|
|
}
|
|
}
|
|
}
|
|
black_box(bitmap_checksum);
|
|
let bitmap_ns = start.elapsed().as_nanos();
|
|
assert_eq!(list_checksum, bitmap_checksum);
|
|
println!("arch={} fields=4096 period={} roots={} payload={} registry={} load_ns={} list_bytes={} bitmap_bytes={} runs={} list_ns={} bitmap_ns={}",
|
|
std::env::consts::ARCH,period,layout.owned_fields.len(),layout.size,b.used(LoadResource::RegistryBytes),load_ns,
|
|
layout.owned_fields.capacity()*size_of::<OwnedField>(),bitmap.capacity()*8,runs,list_ns,bitmap_ns);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn independent_multi_slot_signature_fixture_has_no_serialized_widths() {
|
|
// vec2 import; fn(vec2)->vec2; GET_LOCAL 0; GET_LOCAL 1; RET.
|
|
let types = hex("01 00 00 00 00 00 02 00 00 00");
|
|
let functions=hex("01 00 00 00 00 01 00 00 00 00 00 00 00 00 01 00 00 00 00 00 00 00 00 00 00 00 0e 00 00 00 00 00 00 00 02 00 00 00");
|
|
let code = hex("42 00 00 00 00 00 42 00 01 00 00 00 51 00");
|
|
let empty = [0; 4];
|
|
let bytes = encode_envelope(
|
|
&[
|
|
SectionData { kind: 0, bytes: &empty },
|
|
SectionData { kind: 1, bytes: &functions },
|
|
SectionData { kind: 2, bytes: &code },
|
|
SectionData { kind: 4, bytes: &empty },
|
|
SectionData { kind: 5, bytes: &empty },
|
|
SectionData { kind: 6, bytes: &types },
|
|
SectionData { kind: 7, bytes: &empty },
|
|
SectionData { kind: 8, bytes: &[1, 0, 0, 0, 0, 0, 0, 0] },
|
|
],
|
|
&mut budget(),
|
|
)
|
|
.unwrap();
|
|
let parsed = ParsedPbx::parse(&bytes, &mut budget()).unwrap();
|
|
assert_eq!(
|
|
parsed.registry().function_layout(FunctionId(0)),
|
|
Some(&FunctionLayout {
|
|
parameter_slots: 2,
|
|
result_slots: 2,
|
|
capture_slots: 0,
|
|
captures: vec![]
|
|
})
|
|
);
|
|
let sections = encode_registry(parsed.registry(), &mut budget()).unwrap();
|
|
assert_eq!(sections.functions, functions);
|
|
assert_eq!(sections.types, types);
|
|
}
|