Rijad Zuzo
104 lines
3.1 KiB
GDScript
104 lines
3.1 KiB
GDScript
extends SceneTree
|
|
|
|
const SimulationManagerScript := preload("res://simulation/SimulationManager.gd")
|
|
const BenchmarkScript := preload("res://simulation/benchmark/SimulationScalingBenchmark.gd")
|
|
|
|
var failures: Array[String] = []
|
|
|
|
|
|
func _initialize() -> void:
|
|
call_deferred("_run")
|
|
|
|
|
|
func _run() -> void:
|
|
var first := _run_case(9001)
|
|
var repeated := _run_case(9001)
|
|
var different_seed := _run_case(9002)
|
|
_check(not first.is_empty(), "The benchmark fixture should produce one result")
|
|
if first.is_empty():
|
|
_finish()
|
|
return
|
|
_check(first["fixture_valid"], "The prepared benchmark state should pass schema validation")
|
|
_check(
|
|
(
|
|
int(first["schema_version"]) == SimulationScalingBenchmark.SCHEMA_VERSION
|
|
and StringName(first["workload_id"]) == SimulationScalingBenchmark.WORKLOAD_ID
|
|
and int(first["population"]) == 12
|
|
and int(first["history_seed_events"]) == 24
|
|
and int(first["measured_ticks"]) == 8
|
|
and int(first["npc_updates"]) == 96
|
|
and is_equal_approx(float(first["tick_interval"]), 1.2)
|
|
and int(first["end_tick"]) - int(first["start_tick"]) == 8
|
|
),
|
|
"The result should identify the exact workload and measured update count"
|
|
)
|
|
_check(
|
|
(
|
|
int(first["elapsed_usec"]) > 0
|
|
and int(first["simulation_usec"]) > 0
|
|
and int(first["arrival_usec"]) > 0
|
|
and int(first["start_state_bytes"]) > 0
|
|
and int(first["end_state_bytes"]) >= int(first["start_state_bytes"])
|
|
and int(first["arrivals_processed"]) > 0
|
|
and int(first["events_recorded"]) > 0
|
|
and int(first["end_event_count"]) >= 24
|
|
and String(first["final_checksum"]).length() == 64
|
|
),
|
|
"The benchmark should report timing, state growth, updates, history, and a checksum"
|
|
)
|
|
for deterministic_key in [
|
|
"final_checksum",
|
|
"start_state_bytes",
|
|
"end_state_bytes",
|
|
"state_growth_bytes",
|
|
"start_event_count",
|
|
"end_event_count",
|
|
"events_recorded",
|
|
"start_known_reference_count",
|
|
"end_known_reference_count",
|
|
"arrivals_processed",
|
|
"warmup_arrivals",
|
|
"tick_interval",
|
|
]:
|
|
_check(
|
|
first[deterministic_key] == repeated[deterministic_key],
|
|
"Repeated benchmark runs should preserve %s" % deterministic_key
|
|
)
|
|
_check(
|
|
first["final_checksum"] != different_seed["final_checksum"],
|
|
"A different fixture seed should produce a different deterministic checksum"
|
|
)
|
|
_finish()
|
|
|
|
|
|
func _run_case(seed_value: int) -> Dictionary:
|
|
var manager := SimulationManagerScript.new()
|
|
manager.simulation_seed = seed_value
|
|
manager.debug_logs = false
|
|
manager.set_process(false)
|
|
root.add_child(manager)
|
|
var benchmark := BenchmarkScript.new()
|
|
if not benchmark.prepare_manager(manager, 12, 24, seed_value):
|
|
manager.free()
|
|
return {}
|
|
var fixture_valid := SimulationStateRecord.from_json(manager.serialize_state()) != null
|
|
var result: Dictionary = benchmark.measure_manager(manager, 12, 24, 2, 8)
|
|
result["fixture_valid"] = fixture_valid
|
|
manager.free()
|
|
return result
|
|
|
|
|
|
func _check(condition: bool, message: String) -> void:
|
|
if not condition:
|
|
failures.append(message)
|
|
|
|
|
|
func _finish() -> void:
|
|
if failures.is_empty():
|
|
print("[TEST] Simulation scaling benchmark passed: valid fixture -> stable metrics")
|
|
quit(0)
|
|
return
|
|
for failure in failures:
|
|
push_error("[TEST] " + failure)
|
|
quit(1)
|