translate to english!

This commit is contained in:
Nilton Constantino
2026-01-19 07:28:14 +00:00
parent 38ec13b248
commit 0f3105d622
49 changed files with 2488 additions and 2488 deletions
@@ -9,8 +9,8 @@ use std::collections::HashMap;
use std::sync::Arc;
use std::time::Instant;
/// PrometeuOS (POS): O firmware/base do sistema.
/// Autoridade máxima do boot, periféricos, execução da PVM e tratamento de falhas.
/// PrometeuOS (POS): The system firmware/base.
/// Maximum authority for boot, peripherals, PVM execution, and fault handling.
pub struct PrometeuOS {
pub tick_index: u64,
pub logical_frame_index: u64,
@@ -18,7 +18,7 @@ pub struct PrometeuOS {
pub logical_frame_remaining_cycles: u64,
pub last_frame_cpu_time_us: u64,
// Assets de exemplo (mantidos para compatibilidade com syscalls de áudio v0)
// Example assets (kept for compatibility with v0 audio syscalls)
pub sample_square: Option<Arc<Sample>>,
pub sample_kick: Option<Arc<Sample>>,
pub sample_snare: Option<Arc<Sample>>,
@@ -37,7 +37,7 @@ pub struct PrometeuOS {
pub current_cartridge_app_mode: crate::model::AppMode,
pub logs_written_this_frame: HashMap<u32, u32>,
// Telemetria e Certificação
// Telemetry and Certification
pub telemetry_current: TelemetryFrame,
pub telemetry_last: TelemetryFrame,
pub certifier: Certifier,
@@ -49,7 +49,7 @@ pub struct PrometeuOS {
impl PrometeuOS {
pub const CYCLES_PER_LOGICAL_FRAME: u64 = 100_000;
pub const SLICE_PER_TICK: u64 = 100_000; // Por enquanto, o mesmo, mas permite granularidade diferente
pub const SLICE_PER_TICK: u64 = 100_000; // For now the same, but allows different granularity
pub const MAX_LOG_LEN: usize = 256;
pub const MAX_LOGS_PER_FRAME: u32 = 10;
@@ -83,7 +83,7 @@ impl PrometeuOS {
boot_time,
};
// Inicializa samples básicos (mesma lógica do LogicalHardware)
// Initializes basic samples (same logic as LogicalHardware)
os.sample_square = Some(Arc::new(Self::create_square_sample(440.0, 0.1)));
os.log(LogLevel::Info, LogSource::Pos, 0, "PrometeuOS starting...".to_string());
@@ -135,18 +135,18 @@ impl PrometeuOS {
self.last_frame_cpu_time_us = 0;
}
/// Carrega um cartucho na PVM e reseta o estado de execução.
/// Loads a cartridge into the PVM and resets the execution state.
pub fn initialize_vm(&mut self, vm: &mut VirtualMachine, cartridge: &Cartridge) {
vm.initialize(cartridge.program.clone(), &cartridge.entrypoint);
// Determina o app_id numérico
// Determines the numeric app_id
self.current_app_id = cartridge.app_id;
self.current_cartridge_title = cartridge.title.clone();
self.current_cartridge_app_version = cartridge.app_version.clone();
self.current_cartridge_app_mode = cartridge.app_mode;
}
/// Executa uma única instrução da VM (Debug).
/// Executes a single VM instruction (Debug).
pub fn debug_step_instruction(&mut self, vm: &mut VirtualMachine, hw: &mut dyn HardwareBridge) -> Option<String> {
match vm.step(self, hw) {
Ok(_) => None,
@@ -158,7 +158,7 @@ impl PrometeuOS {
}
}
/// Executa um tick do host (60Hz).
/// Executes a host tick (60Hz).
pub fn step_frame(&mut self, vm: &mut VirtualMachine, signals: &InputSignals, hw: &mut dyn HardwareBridge) -> Option<String> {
let start = std::time::Instant::now();
self.tick_index += 1;
@@ -174,25 +174,25 @@ impl PrometeuOS {
self.logical_frame_remaining_cycles = Self::CYCLES_PER_LOGICAL_FRAME;
self.begin_logical_frame(signals, hw);
// Início do frame: resetar acumulador da telemetria (mas manter frame_index)
// Beginning of frame: reset telemetry accumulator (but keep frame_index)
self.telemetry_current = TelemetryFrame {
frame_index: self.logical_frame_index,
..Default::default()
};
}
// Budget para este tick: o mínimo entre a fatia do tick e o que resta no frame lógico
// Budget for this tick: the minimum between the tick slice and what remains in the logical frame
let budget = std::cmp::min(Self::SLICE_PER_TICK, self.logical_frame_remaining_cycles);
if budget > 0 {
// Executa budget
// Execute budget
let run_result = vm.run_budget(budget, self, hw);
match run_result {
Ok(run) => {
self.logical_frame_remaining_cycles = self.logical_frame_remaining_cycles.saturating_sub(run.cycles_used);
// Acumula métricas
// Accumulates metrics
self.telemetry_current.cycles_used += run.cycles_used;
self.telemetry_current.vm_steps += run.steps_executed;
@@ -205,14 +205,14 @@ impl PrometeuOS {
if run.reason == crate::virtual_machine::LogicalFrameEndingReason::FrameSync {
hw.gfx_mut().render_all();
// Finaliza telemetria do frame (host_cpu_time será refinado no final do tick)
// Finalizes frame telemetry (host_cpu_time will be refined at the end of the tick)
self.telemetry_current.host_cpu_time_us = start.elapsed().as_micros() as u64;
// Certificação (CAP)
// Certification (CAP)
let ts_ms = self.boot_time.elapsed().as_millis() as u64;
self.telemetry_current.violations = self.certifier.evaluate(&self.telemetry_current, &mut self.log_service, ts_ms) as u32;
// Latch: o que o overlay lê
// Latch: what the overlay reads
self.telemetry_last = self.telemetry_current;
self.logical_frame_index += 1;
@@ -235,7 +235,7 @@ impl PrometeuOS {
self.last_frame_cpu_time_us = start.elapsed().as_micros() as u64;
// Se o frame acabou neste tick, atualizamos o tempo real final no latch
// If the frame ended in this tick, we update the final real time in the latch
if !self.logical_frame_active && self.telemetry_last.frame_index == self.logical_frame_index.wrapping_sub(1) {
self.telemetry_last.host_cpu_time_us = self.last_frame_cpu_time_us;
}
@@ -367,16 +367,16 @@ mod tests {
};
os.initialize_vm(&mut vm, &cartridge);
// Primeiro tick
// First tick
os.step_frame(&mut vm, &signals, &mut hw);
let cycles_after_tick_1 = vm.cycles;
assert!(cycles_after_tick_1 >= PrometeuOS::CYCLES_PER_LOGICAL_FRAME);
// Segundo tick - Agora ele NÃO deve ganhar mais budget
// Second tick - Now it SHOULD NOT gain more budget
os.step_frame(&mut vm, &signals, &mut hw);
let cycles_after_tick_2 = vm.cycles;
// CORREÇÃO: Ele não deve ter consumido ciclos no segundo tick porque o budget do frame lógico acabou
// FIX: It should not have consumed cycles in the second tick because the logical frame budget ended
println!("Cycles after tick 1: {}, tick 2: {}", cycles_after_tick_1, cycles_after_tick_2);
assert_eq!(cycles_after_tick_2, cycles_after_tick_1, "VM should NOT have consumed more cycles in the second tick because logical frame budget is exhausted");
}
@@ -388,7 +388,7 @@ mod tests {
let mut hw = Hardware::new();
let signals = InputSignals::default();
// Loop que chama FrameSync:
// Loop that calls FrameSync:
// PUSH_CONST 0 (dummy)
// FrameSync (0x80)
// JMP 0
@@ -407,15 +407,15 @@ mod tests {
};
os.initialize_vm(&mut vm, &cartridge);
// Primeiro tick
// First tick
os.step_frame(&mut vm, &signals, &mut hw);
let cycles_after_tick_1 = vm.cycles;
// Deve ter parado no FrameSync
// Should have stopped at FrameSync
assert!(cycles_after_tick_1 > 0, "VM should have consumed some cycles");
assert!(cycles_after_tick_1 < PrometeuOS::CYCLES_PER_LOGICAL_FRAME);
// Segundo tick - Deve resetar o budget e rodar mais um pouco até o próximo FrameSync
// Second tick - Should reset the budget and run a bit more until the next FrameSync
os.step_frame(&mut vm, &signals, &mut hw);
let cycles_after_tick_2 = vm.cycles;
@@ -430,7 +430,7 @@ mod tests {
os.current_app_id = 123;
// 1. Teste de log normal
// 1. Normal log test
vm.push(Value::Integer(2)); // Info
vm.push(Value::String("Hello Log".to_string()));
let res = os.syscall(0x5001, &mut vm, &mut hw);
@@ -441,7 +441,7 @@ mod tests {
assert_eq!(recent[0].level, LogLevel::Info);
assert_eq!(recent[0].source, LogSource::App { app_id: 123 });
// 2. Teste de truncamento
// 2. Truncation test
let long_msg = "A".repeat(300);
vm.push(Value::Integer(3)); // Warn
vm.push(Value::String(long_msg));
@@ -451,27 +451,27 @@ mod tests {
assert_eq!(recent[0].msg.len(), 256);
assert!(recent[0].msg.starts_with("AAAAA"));
// 3. Teste de Rate Limit
// Já fizemos 2 logs. O limite é 10.
// 3. Rate Limit Test
// We already made 2 logs. The limit is 10.
for i in 0..8 {
vm.push(Value::Integer(2));
vm.push(Value::String(format!("Log {}", i)));
os.syscall(0x5001, &mut vm, &mut hw).unwrap();
}
// O 11º log deve ser ignorado (e deve gerar um aviso do sistema)
// The 11th log should be ignored (and generate a system warning)
vm.push(Value::Integer(2));
vm.push(Value::String("Eleventh log".to_string()));
os.syscall(0x5001, &mut vm, &mut hw).unwrap();
let recent = os.log_service.get_recent(2);
// O último log deve ser o aviso de rate limit (veio depois do 10º log tentado)
// The last log should be the rate limit warning (came after the 10th log attempted)
assert_eq!(recent[1].msg, "App exceeded log limit per frame");
assert_eq!(recent[1].level, LogLevel::Warn);
// O log "Eleventh log" não deve estar lá
// The log "Eleventh log" should not be there
assert_ne!(recent[0].msg, "Eleventh log");
// 4. Teste de reset do rate limit no próximo frame
// 4. Rate limit reset test in the next frame
os.begin_logical_frame(&InputSignals::default(), &mut hw);
vm.push(Value::Integer(2));
vm.push(Value::String("New frame log".to_string()));
@@ -480,7 +480,7 @@ mod tests {
let recent = os.log_service.get_recent(1);
assert_eq!(recent[0].msg, "New frame log");
// 5. Teste de LOG_WRITE_TAG
// 5. LOG_WRITE_TAG test
vm.push(Value::Integer(2)); // Info
vm.push(Value::Integer(42)); // Tag
vm.push(Value::String("Tagged Log".to_string()));
@@ -623,7 +623,7 @@ impl NativeInterface for PrometeuOS {
};
match self.fs.list_dir(&path) {
Ok(entries) => {
// Por enquanto, retorna uma string separada por ';'
// For now, returns a string separated by ';'
let names: Vec<String> = entries.into_iter().map(|e| e.name).collect();
vm.push(Value::String(names.join(";")));
Ok(500)