Investigación de Inicialización de VRAM y Discrepancia en Datos Iniciales

Resumen

Se implementó investigación de inicialización de VRAM y discrepancia en datos iniciales para entender por qué el estado inicial de VRAM tiene tan pocos datos (40 bytes no-cero, 0.65%) cuando el Step 0353 reportó 92-98% de bytes no-cero. Se verificó cómo se inicializa VRAM en el constructor, si los datos iniciales se cargan desde la ROM, cuándo se mide el estado inicial en diferentes steps, y si hay escrituras no-cero que cargan datos iniciales al inicio de la ejecución del CPU.

Concepto de Hardware

Inicialización de VRAM: VRAM se inicializa cuando se construye MMU. En el hardware real, VRAM puede contener datos aleatorios al inicio. Algunos emuladores inicializan VRAM con ceros, otros con valores aleatorios. En nuestro emulador, VRAM se inicializa con ceros en el constructor de MMU (memory_(MEMORY_SIZE, 0)), lo que significa que VRAM también se inicializa con ceros.

Carga de Datos desde la ROM: Las ROMs de Game Boy generalmente no tienen datos iniciales en VRAM. Los datos iniciales se generan durante la inicialización del juego. Algunos juegos cargan tiles iniciales desde la ROM durante la inicialización. Sin embargo, en nuestro emulador, la ROM se carga después de que MMU se construye, por lo que VRAM ya está inicializada con ceros cuando se carga la ROM.

Timing de Medición: El estado de VRAM puede cambiar rápidamente durante la inicialización. Medir en diferentes momentos puede dar resultados diferentes. Es importante medir en el momento correcto para obtener resultados precisos. El Step 0353 midió el estado inicial cuando se carga la ROM, mientras que el Step 0354 midió el estado inicial cuando se detecta el primer borrado. Esta diferencia en el timing puede explicar la discrepancia entre los dos steps.

Generación de Datos Iniciales: Los datos iniciales pueden generarse durante la inicialización del juego. El juego puede escribir tiles iniciales a VRAM durante la inicialización, antes de que empecemos a monitorear. Si estas escrituras ocurren antes de que empecemos a monitorear, no las detectaremos, pero VRAM tendrá datos cuando empecemos a monitorear.

Implementación

Se implementaron 5 tareas principales de diagnóstico según el plan Step 0355:

1. Verificación de Inicialización de VRAM en el Constructor (MMU.cpp)

Se agregó código en el constructor de MMU para verificar el estado de VRAM inmediatamente después de la inicialización. El código cuenta bytes no-cero en VRAM y genera un log con estadísticas.

// --- Step 0355: Verificación de Inicialización de VRAM ---
// Verificar el estado de VRAM inmediatamente después de la inicialización
int non_zero_bytes = 0;
for (uint16_t addr = 0x8000; addr < 0x9800; addr++) {
    uint8_t byte = memory_[addr];
    if (byte != 0x00) {
        non_zero_bytes++;
    }
}

printf("[MMU-VRAM-INIT] VRAM initialized | Non-zero bytes: %d/6144 (%.2f%%)\n",
       non_zero_bytes, (non_zero_bytes * 100.0) / 6144);

if (non_zero_bytes < 200) {
    printf("[MMU-VRAM-INIT] ⚠️ ADVERTENCIA: VRAM está vacía después de la inicialización!\n");
}
// -----------------------------------------

2. Verificación de Carga de Datos Iniciales desde la ROM (MMU.cpp)

Se agregó código en MMU::load_rom() para verificar el estado de VRAM después de cargar la ROM. El código cuenta bytes no-cero en VRAM y genera un log con estadísticas.

// --- Step 0355: Verificación de Carga de Datos Iniciales desde la ROM ---
// Verificar el estado de VRAM después de cargar la ROM
int non_zero_bytes = 0;
for (uint16_t addr = 0x8000; addr < 0x9800; addr++) {
    uint8_t byte = memory_[addr];
    if (byte != 0x00) {
        non_zero_bytes++;
    }
}

printf("[MMU-VRAM-AFTER-ROM-LOAD] VRAM after ROM load | Non-zero bytes: %d/6144 (%.2f%%)\n",
       non_zero_bytes, (non_zero_bytes * 100.0) / 6144);

if (non_zero_bytes < 200) {
    printf("[MMU-VRAM-AFTER-ROM-LOAD] ⚠️ ADVERTENCIA: VRAM está vacía después de cargar la ROM!\n");
}
// -----------------------------------------

3. Verificación de Discrepancia en la Medición del Estado Inicial (MMU.cpp)

Se agregó función MMU::check_vram_state_at_point() para verificar el estado de VRAM en diferentes momentos. Esta función se llama en múltiples puntos (constructor, después de cargar ROM, cuando el CPU empieza) para identificar la discrepancia.

// --- Step 0355: Verificación de Estado de VRAM en Múltiples Puntos ---
void MMU::check_vram_state_at_point(const char* point_name) {
    static std::map<std::string, bool> checked_points;
    
    if (checked_points.find(point_name) == checked_points.end()) {
        checked_points[point_name] = true;
        
        int non_zero_bytes = 0;
        int complete_tiles = 0;
        
        for (uint16_t addr = 0x8000; addr < 0x9800; addr += 16) {
            bool tile_has_data = false;
            int tile_non_zero = 0;
            
            for (int i = 0; i < 16; i++) {
                uint8_t byte = memory_[addr - 0x8000 + i];
                if (byte != 0x00) {
                    non_zero_bytes++;
                    tile_non_zero++;
                    tile_has_data = true;
                }
            }
            
            if (tile_non_zero >= 8) {
                complete_tiles++;
            }
        }
        
        printf("[MMU-VRAM-STATE-POINT] Point: %s | Non-zero bytes: %d/6144 (%.2f%%) | "
               "Complete tiles: %d/384 (%.2f%%)\n",
               point_name,
               non_zero_bytes, (non_zero_bytes * 100.0) / 6144,
               complete_tiles, (complete_tiles * 100.0) / 384);
    }
}
// -----------------------------------------

4. Verificación de Escrituras desde el Inicio de la Ejecución del CPU (MMU.cpp)

Se agregó código en MMU::write() para monitorear todas las escrituras a VRAM desde el primer ciclo del CPU. El código detecta cuando el CPU empieza a ejecutar y verifica el estado de VRAM en ese momento. También loggea las primeras 500 escrituras no-cero con información detallada.

// --- Step 0355: Monitoreo de Escrituras desde el Inicio de la Ejecución ---
// Monitorear todas las escrituras a VRAM desde el primer ciclo del CPU
static int vram_write_from_cpu_start_count = 0;
static int vram_write_non_zero_from_cpu_start = 0;
static bool cpu_started = false;

// Detectar cuando el CPU empieza a ejecutar (primera escritura a cualquier dirección)
if (!cpu_started) {
    cpu_started = true;
    printf("[MMU-VRAM-CPU-START] CPU started executing | Monitoring VRAM writes from now\n");
    
    // Verificar estado de VRAM cuando el CPU empieza
    int non_zero_bytes = 0;
    for (uint16_t check_addr = 0x8000; check_addr < 0x9800; check_addr++) {
        uint8_t byte = memory_[check_addr];
        if (byte != 0x00) {
            non_zero_bytes++;
        }
    }
    
    printf("[MMU-VRAM-CPU-START] VRAM state when CPU starts | Non-zero bytes: %d/6144 (%.2f%%)\n",
           non_zero_bytes, (non_zero_bytes * 100.0) / 6144);
    
    // Verificar estado de VRAM en este punto
    check_vram_state_at_point("CPU Start");
}

if (addr >= 0x8000 && addr < 0x9800) {
    vram_write_from_cpu_start_count++;
    
    if (value != 0x00) {
        vram_write_non_zero_from_cpu_start++;
        
        // Loggear todas las escrituras no-cero (no solo las primeras 100)
        if (vram_write_non_zero_from_cpu_start <= 500) {
            // Obtener PC del CPU (ya está disponible en debug_current_pc)
            uint16_t pc = debug_current_pc;
            
            // Obtener frame desde PPU (si está disponible)
            uint64_t frame = 0;
            if (ppu_ != nullptr) {
                frame = ppu_->get_frame_counter();
            }
            
            printf("[MMU-VRAM-WRITE-FROM-CPU-START] Non-zero write #%d | Addr=0x%04X | Value=0x%02X | "
                   "PC=0x%04X | Frame %llu | Total writes=%d\n",
                   vram_write_non_zero_from_cpu_start, addr, value, pc,
                   static_cast<unsigned long long>(frame),
                   vram_write_from_cpu_start_count);
        }
    }
    
    // Loggear estadísticas cada 1000 escrituras
    if (vram_write_from_cpu_start_count > 0 && vram_write_from_cpu_start_count % 1000 == 0) {
        printf("[MMU-VRAM-WRITE-FROM-CPU-START-STATS] Total writes=%d | Non-zero writes=%d | "
               "Non-zero ratio=%.2f%%\n",
               vram_write_from_cpu_start_count, vram_write_non_zero_from_cpu_start,
               (vram_write_non_zero_from_cpu_start * 100.0) / vram_write_from_cpu_start_count);
    }
}
// -----------------------------------------

Archivos Modificados

• src/core/cpp/MMU.cpp - Agregada verificación de inicialización de VRAM en el constructor, verificación de carga de datos iniciales desde la ROM, función check_vram_state_at_point(), y monitoreo de escrituras desde el inicio de la ejecución del CPU
• src/core/cpp/MMU.hpp - Agregada declaración de check_vram_state_at_point()

Tests y Verificación

Se ejecutaron pruebas con las 5 ROMs en paralelo (~2.5 minutos total) para analizar la inicialización de VRAM y la discrepancia en datos iniciales:

• ROMs probadas: pkmn.gb, tetris.gb, mario.gbc, pkmn-amarillo.gb, Oro.gbc
• Comando ejecutado: timeout 150 python3 main.py roms/<rom>.gb 2>&1 | tee logs/test_<rom>_step0355.log & (5 procesos en paralelo)
• Análisis de logs: Se usaron comandos grep y head para extraer información específica sin saturar el contexto

Resultados Clave

• Inicialización de VRAM (Constructor): ✅ 0 bytes no-cero (0.00%) - como se esperaba
• Después de cargar ROM (Inmediato): ✅ 0 bytes no-cero (0.00%) - confirma que las ROMs no tienen datos iniciales
• Después de load_test_tiles(): ⚠️ 95.49% bytes no-cero (5867/6144) - carga tiles de prueba
• Estado cuando CPU empieza: ⚠️ 0.65% bytes no-cero (40/6144) - el juego borra los tiles de prueba
• Escrituras desde CPU Start: ❌ 0% de escrituras no-cero - todas las escrituras son ceros (0x00)

Comandos de Análisis

# Verificar inicialización de VRAM
grep "\[MMU-VRAM-INIT\]" logs/test_*_step0355.log | head -n 10

# Verificar estado después de cargar ROM
grep "\[MMU-VRAM-AFTER-ROM-LOAD\]" logs/test_*_step0355.log | head -n 10

# Verificar estado en múltiples puntos
grep "\[MMU-VRAM-STATE-POINT\]" logs/test_*_step0355.log | head -n 30

# Verificar escrituras desde el inicio del CPU
grep "\[MMU-VRAM-CPU-START\]" logs/test_*_step0355.log | head -n 20
grep "\[MMU-VRAM-WRITE-FROM-CPU-START\]" logs/test_*_step0355.log | head -n 50

Ejemplo de Logs

[MMU-VRAM-INIT] VRAM initialized | Non-zero bytes: 0/6144 (0.00%)
[MMU-VRAM-AFTER-ROM-LOAD] VRAM after ROM load | Non-zero bytes: 0/6144 (0.00%)
[MMU-VRAM-INITIAL-STATE] VRAM initial state | Non-zero bytes: 5867/6144 (95.49%)
[LOAD-TEST-TILES] Función llamada
[LOAD-TEST-TILES] Cargando tiles de prueba en VRAM...
[MMU-VRAM-CPU-START] VRAM state when CPU starts | Non-zero bytes: 40/6144 (0.65%)
[MMU-VRAM-ERASE-DETECTION] Erase #1 | Addr=0x8010 | Old value=0xAA | PC=0x36E3 | Frame 6

Validación Nativa

Validación de módulo compilado C++: El código se compiló exitosamente sin errores (solo warnings menores sobre variables no usadas). Se agregó #include <string> para usar std::string en check_vram_state_at_point().

Hallazgos y Conclusiones

Hallazgos Principales

• Inicialización de VRAM: ✅ VRAM se inicializa correctamente con ceros en el constructor de MMU (0 bytes no-cero, 0.00%).
• Carga de Datos desde la ROM: ✅ Después de cargar la ROM, VRAM sigue teniendo 0 bytes no-cero (0.00%), lo que confirma que las ROMs no tienen datos iniciales en VRAM.
• Causa de la Discrepancia Identificada: ⚠️ La discrepancia entre el Step 0353 (92-98% de bytes no-cero) y el Step 0354 (40 bytes no-cero, 0.65%) se debe a que:
  • load_test_tiles() carga tiles de prueba en VRAM (95.49% de bytes no-cero)
  • El juego borra estos tiles de prueba cuando empieza a ejecutarse (Frame 6, PC=0x36E3)
  • Cuando el CPU empieza, VRAM tiene solo 0.65% de bytes no-cero (40/6144)
• El Juego Borra los Tiles de Prueba: ⚠️ El juego borra los tiles de prueba que load_test_tiles() cargó. Los borrados ocurren en Frame 6, PC=0x36E3, cuando el LCD está encendido (no en VBLANK).
• Escrituras desde el Inicio del CPU: ❌ 0% de escrituras no-cero desde el inicio del CPU. Todas las escrituras a VRAM son ceros (0x00), lo que significa que el juego no está cargando tiles nuevos, solo está borrando los tiles de prueba.

Secuencia Completa Identificada

1. Constructor: VRAM = 0 bytes no-cero (0.00%) ✅
2. load_rom(): VRAM = 0 bytes no-cero (0.00%) ✅ - Las ROMs no tienen datos iniciales
3. load_test_tiles(): VRAM = 95.49% bytes no-cero (5867/6144) ⚠️ - Carga tiles de prueba
4. CPU empieza: VRAM = 0.65% bytes no-cero (40/6144) ⚠️ - El juego ya borró la mayoría de los tiles
5. Frame 6, PC=0x36E3: El juego borra los tiles de prueba restantes ⚠️

Conclusiones

El estado inicial de VRAM se inicializa correctamente con ceros en el constructor de MMU. Las ROMs no tienen datos iniciales en VRAM, por lo que VRAM sigue vacía después de cargar la ROM. La discrepancia entre los steps se debe a que load_test_tiles() carga tiles de prueba que luego el juego borra cuando empieza a ejecutarse.

Problema identificado: El juego borra los tiles de prueba que load_test_tiles() carga, y luego no carga tiles nuevos (todas las escrituras son ceros). Esto explica por qué VRAM nunca se llena con tiles durante la ejecución.

Fuentes Consultadas

• Pan Docs: VRAM (Video RAM)
• Pan Docs: Power Up Sequence
• Pan Docs: Memory Map

Integridad Educativa

Próximos Pasos

• [x] Ejecutar pruebas: ✅ Ejecutadas las pruebas con las 5 ROMs en paralelo y analizados los logs.
• [x] Analizar logs: ✅ Identificada la causa de la discrepancia: load_test_tiles() carga tiles de prueba que luego el juego borra.
• [ ] Step 0356: Investigar por qué el juego no carga tiles nuevos después de borrar los tiles de prueba. Verificar si hay un problema con el timing de carga de tiles o si el juego espera condiciones específicas que no se están cumpliendo.
• [ ] Considerar desactivar load_test_tiles(): Para pruebas futuras, considerar desactivar load_test_tiles() y ver el comportamiento real del juego sin tiles de prueba.