suyu/src/core/tracer/recorder.cpp

// Copyright 2015 Citra Emulator Project
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.

#include <cstring>

#include "common/assert.h"
#include "common/file_util.h"
#include "common/logging/log.h"

#include "recorder.h"

namespace CiTrace {

Recorder::Recorder(const InitialState& initial_state) : initial_state(initial_state) {}

void Recorder::Finish(const std::string& filename) {
    // Setup CiTrace header
    CTHeader header;
    std::memcpy(header.magic, CTHeader::ExpectedMagicWord(), 4);
    header.version = CTHeader::ExpectedVersion();
    header.header_size = sizeof(CTHeader);

    // Calculate file offsets
    auto& initial = header.initial_state_offsets;

    initial.gpu_registers_size = static_cast<u32>(initial_state.gpu_registers.size());
    initial.lcd_registers_size = static_cast<u32>(initial_state.lcd_registers.size());
    initial.pica_registers_size = static_cast<u32>(initial_state.pica_registers.size());
    initial.default_attributes_size = static_cast<u32>(initial_state.default_attributes.size());
    initial.vs_program_binary_size = static_cast<u32>(initial_state.vs_program_binary.size());
    initial.vs_swizzle_data_size = static_cast<u32>(initial_state.vs_swizzle_data.size());
    initial.vs_float_uniforms_size = static_cast<u32>(initial_state.vs_float_uniforms.size());
    initial.gs_program_binary_size = static_cast<u32>(initial_state.gs_program_binary.size());
    initial.gs_swizzle_data_size = static_cast<u32>(initial_state.gs_swizzle_data.size());
    initial.gs_float_uniforms_size = static_cast<u32>(initial_state.gs_float_uniforms.size());
    header.stream_size = static_cast<u32>(stream.size());

    initial.gpu_registers = sizeof(header);
    initial.lcd_registers = initial.gpu_registers + initial.gpu_registers_size * sizeof(u32);
    initial.pica_registers = initial.lcd_registers + initial.lcd_registers_size * sizeof(u32);
    ;
    initial.default_attributes = initial.pica_registers + initial.pica_registers_size * sizeof(u32);
    initial.vs_program_binary =
        initial.default_attributes + initial.default_attributes_size * sizeof(u32);
    initial.vs_swizzle_data =
        initial.vs_program_binary + initial.vs_program_binary_size * sizeof(u32);
    initial.vs_float_uniforms =
        initial.vs_swizzle_data + initial.vs_swizzle_data_size * sizeof(u32);
    initial.gs_program_binary =
        initial.vs_float_uniforms + initial.vs_float_uniforms_size * sizeof(u32);
    initial.gs_swizzle_data =
        initial.gs_program_binary + initial.gs_program_binary_size * sizeof(u32);
    initial.gs_float_uniforms =
        initial.gs_swizzle_data + initial.gs_swizzle_data_size * sizeof(u32);
    header.stream_offset = initial.gs_float_uniforms + initial.gs_float_uniforms_size * sizeof(u32);

    // Iterate through stream elements, update relevant stream element data
    for (auto& stream_element : stream) {
        switch (stream_element.data.type) {
        case MemoryLoad: {
            auto& file_offset = memory_regions[stream_element.hash];
            if (!stream_element.uses_existing_data) {
                file_offset = header.stream_offset;
            }
            stream_element.data.memory_load.file_offset = file_offset;
            break;
        }

        default:
            // Other commands don't use any extra data
            DEBUG_ASSERT(stream_element.extra_data.size() == 0);
            break;
        }
        header.stream_offset += static_cast<u32>(stream_element.extra_data.size());
    }

    try {
        // Open file and write header
        FileUtil::IOFile file(filename, "wb");
        size_t written = file.WriteObject(header);
        if (written != 1 || file.Tell() != initial.gpu_registers)
            throw "Failed to write header";

        // Write initial state
        written =
            file.WriteArray(initial_state.gpu_registers.data(), initial_state.gpu_registers.size());
        if (written != initial_state.gpu_registers.size() || file.Tell() != initial.lcd_registers)
            throw "Failed to write GPU registers";

        written =
            file.WriteArray(initial_state.lcd_registers.data(), initial_state.lcd_registers.size());
        if (written != initial_state.lcd_registers.size() || file.Tell() != initial.pica_registers)
            throw "Failed to write LCD registers";

        written = file.WriteArray(initial_state.pica_registers.data(),
                                  initial_state.pica_registers.size());
        if (written != initial_state.pica_registers.size() ||
            file.Tell() != initial.default_attributes)
            throw "Failed to write Pica registers";

        written = file.WriteArray(initial_state.default_attributes.data(),
                                  initial_state.default_attributes.size());
        if (written != initial_state.default_attributes.size() ||
            file.Tell() != initial.vs_program_binary)
            throw "Failed to write default vertex attributes";

        written = file.WriteArray(initial_state.vs_program_binary.data(),
                                  initial_state.vs_program_binary.size());
        if (written != initial_state.vs_program_binary.size() ||
            file.Tell() != initial.vs_swizzle_data)
            throw "Failed to write vertex shader program binary";

        written = file.WriteArray(initial_state.vs_swizzle_data.data(),
                                  initial_state.vs_swizzle_data.size());
        if (written != initial_state.vs_swizzle_data.size() ||
            file.Tell() != initial.vs_float_uniforms)
            throw "Failed to write vertex shader swizzle data";

        written = file.WriteArray(initial_state.vs_float_uniforms.data(),
                                  initial_state.vs_float_uniforms.size());
        if (written != initial_state.vs_float_uniforms.size() ||
            file.Tell() != initial.gs_program_binary)
            throw "Failed to write vertex shader float uniforms";

        written = file.WriteArray(initial_state.gs_program_binary.data(),
                                  initial_state.gs_program_binary.size());
        if (written != initial_state.gs_program_binary.size() ||
            file.Tell() != initial.gs_swizzle_data)
            throw "Failed to write geomtry shader program binary";

        written = file.WriteArray(initial_state.gs_swizzle_data.data(),
                                  initial_state.gs_swizzle_data.size());
        if (written != initial_state.gs_swizzle_data.size() ||
            file.Tell() != initial.gs_float_uniforms)
            throw "Failed to write geometry shader swizzle data";

        written = file.WriteArray(initial_state.gs_float_uniforms.data(),
                                  initial_state.gs_float_uniforms.size());
        if (written != initial_state.gs_float_uniforms.size() ||
            file.Tell() != initial.gs_float_uniforms + sizeof(u32) * initial.gs_float_uniforms_size)
            throw "Failed to write geometry shader float uniforms";

        // Iterate through stream elements, write "extra data"
        for (const auto& stream_element : stream) {
            if (stream_element.extra_data.size() == 0)
                continue;

            written =
                file.WriteBytes(stream_element.extra_data.data(), stream_element.extra_data.size());
            if (written != stream_element.extra_data.size())
                throw "Failed to write extra data";
        }

        if (file.Tell() != header.stream_offset)
            throw "Unexpected end of extra data";

        // Write actual stream elements
        for (const auto& stream_element : stream) {
            if (1 != file.WriteObject(stream_element.data))
                throw "Failed to write stream element";
        }
    } catch (const char* str) {
        LOG_ERROR(HW_GPU, "Writing CiTrace file failed: %s", str);
    }
}

void Recorder::FrameFinished() {
    stream.push_back({{FrameMarker}});
}

void Recorder::MemoryAccessed(const u8* data, u32 size, u32 physical_address) {
    StreamElement element = {{MemoryLoad}};
    element.data.memory_load.size = size;
    element.data.memory_load.physical_address = physical_address;

    // Compute hash over given memory region to check if the contents are already stored internally
    boost::crc_32_type result;
    result.process_bytes(data, size);
    element.hash = result.checksum();

    element.uses_existing_data = (memory_regions.find(element.hash) != memory_regions.end());
    if (!element.uses_existing_data) {
        element.extra_data.resize(size);
        memcpy(element.extra_data.data(), data, size);
        memory_regions.insert({element.hash, 0}); // file offset will be initialized in Finish()
    }

    stream.push_back(element);
}

template <typename T>
void Recorder::RegisterWritten(u32 physical_address, T value) {
    StreamElement element = {{RegisterWrite}};
    element.data.register_write.size =
        (sizeof(T) == 1) ? CTRegisterWrite::SIZE_8
                         : (sizeof(T) == 2) ? CTRegisterWrite::SIZE_16
                                            : (sizeof(T) == 4) ? CTRegisterWrite::SIZE_32
                                                               : CTRegisterWrite::SIZE_64;
    element.data.register_write.physical_address = physical_address;
    element.data.register_write.value = value;

    stream.push_back(element);
}

template void Recorder::RegisterWritten(u32, u8);
template void Recorder::RegisterWritten(u32, u16);
template void Recorder::RegisterWritten(u32, u32);
template void Recorder::RegisterWritten(u32, u64);
}