From 902fa4da52737d43e04c2a028658ad9840811a89 Mon Sep 17 00:00:00 2001 From: Tony Wasserka Date: Sat, 4 Apr 2015 12:57:31 +0200 Subject: Add CiTrace recording support. This is exposed in the GUI as a new "CiTrace Recording" widget. Playback is implemented by a standalone 3DS homebrew application (which only runs reliably within Citra currently; on an actual 3DS it will often crash still). --- src/core/tracer/recorder.cpp | 198 +++++++++++++++++++++++++++++++++++++++++++ src/core/tracer/recorder.h | 92 ++++++++++++++++++++ src/core/tracer/tracer.h | 98 +++++++++++++++++++++ 3 files changed, 388 insertions(+) create mode 100644 src/core/tracer/recorder.cpp create mode 100644 src/core/tracer/recorder.h create mode 100644 src/core/tracer/tracer.h (limited to 'src/core/tracer') diff --git a/src/core/tracer/recorder.cpp b/src/core/tracer/recorder.cpp new file mode 100644 index 00000000..73ebdd38 --- /dev/null +++ b/src/core/tracer/recorder.cpp @@ -0,0 +1,198 @@ +// Copyright 2015 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#include + +#include "common/assert.h" +#include "common/file_util.h" +#include "common/logging/log.h" + +#include "recorder.h" + +namespace CiTrace { + +Recorder::Recorder(u32* gpu_registers, u32 gpu_registers_size, + u32* lcd_registers, u32 lcd_registers_size, + u32* pica_registers, u32 pica_registers_size, + u32* vs_program_binary, u32 vs_program_binary_size, + u32* vs_swizzle_data, u32 vs_swizzle_data_size, + u32* vs_float_uniforms, u32 vs_float_uniforms_size, + u32* gs_program_binary, u32 gs_program_binary_size, + u32* gs_swizzle_data, u32 gs_swizzle_data_size, + u32* gs_float_uniforms, u32 gs_float_uniforms_size) + : gpu_registers(gpu_registers, gpu_registers + gpu_registers_size), + lcd_registers(lcd_registers, lcd_registers + lcd_registers_size), + pica_registers(pica_registers, pica_registers + pica_registers_size), + vs_program_binary(vs_program_binary, vs_program_binary + vs_program_binary_size), + vs_swizzle_data(vs_swizzle_data, vs_swizzle_data + vs_swizzle_data_size), + vs_float_uniforms(vs_float_uniforms, vs_float_uniforms + vs_float_uniforms_size), + gs_program_binary(gs_program_binary, gs_program_binary + gs_program_binary_size), + gs_swizzle_data(gs_swizzle_data, gs_swizzle_data + gs_swizzle_data_size), + gs_float_uniforms(gs_float_uniforms, gs_float_uniforms + gs_float_uniforms_size) { + +} + +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 = gpu_registers.size(); + initial.lcd_registers_size = lcd_registers.size(); + initial.pica_registers_size = pica_registers.size(); + initial.vs_program_binary_size = vs_program_binary.size(); + initial.vs_swizzle_data_size = vs_swizzle_data.size(); + initial.vs_float_uniforms_size = vs_float_uniforms.size(); + initial.gs_program_binary_size = gs_program_binary.size(); + initial.gs_swizzle_data_size = gs_swizzle_data.size(); + initial.gs_float_uniforms_size = gs_float_uniforms.size(); + header.stream_size = 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.vs_program_binary = initial.pica_registers + initial.pica_registers_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 += 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(gpu_registers.data(), gpu_registers.size()); + if (written != gpu_registers.size() || file.Tell() != initial.lcd_registers) + throw "Failed to write GPU registers"; + + written = file.WriteArray(lcd_registers.data(), lcd_registers.size()); + if (written != lcd_registers.size() || file.Tell() != initial.pica_registers) + throw "Failed to write LCD registers"; + + written = file.WriteArray(pica_registers.data(), pica_registers.size()); + if (written != pica_registers.size() || file.Tell() != initial.vs_program_binary) + throw "Failed to write Pica registers"; + + written = file.WriteArray(vs_program_binary.data(), vs_program_binary.size()); + if (written != vs_program_binary.size() || file.Tell() != initial.vs_swizzle_data) + throw "Failed to write vertex shader program binary"; + + written = file.WriteArray(vs_swizzle_data.data(), vs_swizzle_data.size()); + if (written != vs_swizzle_data.size() || file.Tell() != initial.vs_float_uniforms) + throw "Failed to write vertex shader swizzle data"; + + written = file.WriteArray(vs_float_uniforms.data(), vs_float_uniforms.size()); + if (written != vs_float_uniforms.size() || file.Tell() != initial.gs_program_binary) + throw "Failed to write vertex shader float uniforms"; + + written = file.WriteArray(gs_program_binary.data(), gs_program_binary.size()); + if (written != gs_program_binary.size() || file.Tell() != initial.gs_swizzle_data) + throw "Failed to write geomtry shader program binary"; + + written = file.WriteArray(gs_swizzle_data.data(), gs_swizzle_data.size()); + if (written != gs_swizzle_data.size() || file.Tell() != initial.gs_float_uniforms) + throw "Failed to write geometry shader swizzle data"; + + written = file.WriteArray(gs_float_uniforms.data(), gs_float_uniforms.size()); + if (written != 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 +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); + +} diff --git a/src/core/tracer/recorder.h b/src/core/tracer/recorder.h new file mode 100644 index 00000000..8fec0a97 --- /dev/null +++ b/src/core/tracer/recorder.h @@ -0,0 +1,92 @@ +// Copyright 2015 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#pragma once + +#include +#include + +#include + +#include "common/common_types.h" + +#include "tracer.h" + +namespace CiTrace { + +class Recorder { +public: + /** + * Recorder constructor + * @param vs_float_uniforms Pointer to an array of 32-bit-aligned 24-bit floating point values. + */ + Recorder(u32* gpu_registers, u32 gpu_registers_size, + u32* lcd_registers, u32 lcd_registers_size, + u32* pica_registers, u32 pica_registers_size, + u32* vs_program_binary, u32 vs_program_binary_size, + u32* vs_swizzle_data, u32 vs_swizzle_data_size, + u32* vs_float_uniforms, u32 vs_float_uniforms_size, + u32* gs_program_binary, u32 gs_program_binary_size, + u32* gs_swizzle_data, u32 gs_swizzle_data_size, + u32* gs_float_uniforms, u32 gs_float_uniforms_size); + + /// Finish recording of this Citrace and save it using the given filename. + void Finish(const std::string& filename); + + /// Mark end of a frame + void FrameFinished(); + + /** + * Store a copy of the given memory range in the recording. + * @note Use this whenever the GPU is about to access a particular memory region. + * @note The implementation will make sure to minimize redundant memory updates. + */ + void MemoryAccessed(const u8* data, u32 size, u32 physical_address); + + /** + * Record a register write. + * @note Use this whenever a GPU-related MMIO register has been written to. + */ + template + void RegisterWritten(u32 physical_address, T value); + +private: + // Initial state of recording start + std::vector gpu_registers; + std::vector lcd_registers; + std::vector pica_registers; + std::vector vs_program_binary; + std::vector vs_swizzle_data; + std::vector vs_float_uniforms; + std::vector gs_program_binary; + std::vector gs_swizzle_data; + std::vector gs_float_uniforms; + + // Command stream + struct StreamElement { + CTStreamElement data; + + /** + * Extra data to store along "core" data. + * This is e.g. used for data used in MemoryUpdates. + */ + std::vector extra_data; + + /// Optional CRC hash (e.g. for hashing memory regions) + boost::crc_32_type::value_type hash; + + /// If true, refer to data already written to the output file instead of extra_data + bool uses_existing_data; + }; + + std::vector stream; + + /** + * Internal cache which maps hashes of memory contents to file offsets at which those memory + * contents are stored. + */ + std::unordered_map memory_regions; +}; + +} // namespace diff --git a/src/core/tracer/tracer.h b/src/core/tracer/tracer.h new file mode 100644 index 00000000..1545d743 --- /dev/null +++ b/src/core/tracer/tracer.h @@ -0,0 +1,98 @@ +// Copyright 2015 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#pragma once + +#include + +namespace CiTrace { + +// NOTE: Things are stored in little-endian + +#pragma pack(1) + +struct CTHeader { + static const char* ExpectedMagicWord() { + return "CiTr"; + } + + static uint32_t ExpectedVersion() { + return 1; + } + + char magic[4]; + uint32_t version; + uint32_t header_size; + + struct { + // NOTE: Register range sizes are technically hardware-constants, but the actual limits + // aren't known. Hence we store the presumed limits along the offsets. + // Sizes are given in uint32_t units. + uint32_t gpu_registers; + uint32_t gpu_registers_size; + uint32_t lcd_registers; + uint32_t lcd_registers_size; + uint32_t pica_registers; + uint32_t pica_registers_size; + uint32_t vs_program_binary; + uint32_t vs_program_binary_size; + uint32_t vs_swizzle_data; + uint32_t vs_swizzle_data_size; + uint32_t vs_float_uniforms; + uint32_t vs_float_uniforms_size; + uint32_t gs_program_binary; + uint32_t gs_program_binary_size; + uint32_t gs_swizzle_data; + uint32_t gs_swizzle_data_size; + uint32_t gs_float_uniforms; + uint32_t gs_float_uniforms_size; + + // Other things we might want to store here: + // - Initial framebuffer data, maybe even a full copy of FCRAM/VRAM + // - Default vertex attributes + } initial_state_offsets; + + uint32_t stream_offset; + uint32_t stream_size; +}; + +enum CTStreamElementType : uint32_t { + FrameMarker = 0xE1, + MemoryLoad = 0xE2, + RegisterWrite = 0xE3, +}; + +struct CTMemoryLoad { + uint32_t file_offset; + uint32_t size; + uint32_t physical_address; + uint32_t pad; +}; + +struct CTRegisterWrite { + uint32_t physical_address; + + enum : uint32_t { + SIZE_8 = 0xD1, + SIZE_16 = 0xD2, + SIZE_32 = 0xD3, + SIZE_64 = 0xD4 + } size; + + // TODO: Make it clearer which bits of this member are used for sizes other than 32 bits + uint64_t value; +}; + +struct CTStreamElement { + CTStreamElementType type; + + union { + CTMemoryLoad memory_load; + CTRegisterWrite register_write; + }; +}; + +#pragma pack() + +} -- cgit v1.2.3 From fd62580985b2f2d8f65b940148211bedc8d08404 Mon Sep 17 00:00:00 2001 From: Tony Wasserka Date: Thu, 21 May 2015 02:51:28 +0200 Subject: CiTrace: Record default vertex attributes. --- src/citra_qt/debugger/graphics_tracing.cpp | 8 +++ src/core/CMakeLists.txt | 2 +- src/core/tracer/citrace.h | 101 +++++++++++++++++++++++++++++ src/core/tracer/recorder.cpp | 70 +++++++++++--------- src/core/tracer/recorder.h | 23 ++++--- src/core/tracer/tracer.h | 98 ---------------------------- 6 files changed, 162 insertions(+), 140 deletions(-) create mode 100644 src/core/tracer/citrace.h delete mode 100644 src/core/tracer/tracer.h (limited to 'src/core/tracer') diff --git a/src/citra_qt/debugger/graphics_tracing.cpp b/src/citra_qt/debugger/graphics_tracing.cpp index eac40582..3e88346c 100644 --- a/src/citra_qt/debugger/graphics_tracing.cpp +++ b/src/citra_qt/debugger/graphics_tracing.cpp @@ -62,12 +62,20 @@ void GraphicsTracingWidget::StartRecording() { // Encode floating point numbers to 24-bit values // TODO: Drop this explicit conversion once we store float24 values bit-correctly internally. + std::array, 16> default_attributes; + for (unsigned i = 0; i < 16; ++i) { + for (unsigned comp = 0; comp < 3; ++comp) { + default_attributes[i][comp] = nihstro::to_float24(Pica::g_state.vs.default_attributes[i][comp].ToFloat32()); + } + } + std::array, 96> vs_float_uniforms; for (unsigned i = 0; i < 96; ++i) for (unsigned comp = 0; comp < 3; ++comp) vs_float_uniforms[i][comp] = nihstro::to_float24(Pica::g_state.vs.uniforms.f[i][comp].ToFloat32()); auto recorder = new CiTrace::Recorder((u32*)&GPU::g_regs, 0x700, nullptr, 0, (u32*)&Pica::g_state.regs, 0x300, + (u32*)default_attributes.data(), default_attributes.size() * 4, shader_binary.data(), shader_binary.size(), swizzle_data.data(), swizzle_data.size(), (u32*)vs_float_uniforms.data(), vs_float_uniforms.size() * 4, diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt index 5066eb25..8267ee58 100644 --- a/src/core/CMakeLists.txt +++ b/src/core/CMakeLists.txt @@ -245,7 +245,7 @@ set(HEADERS loader/loader.h loader/ncch.h tracer/recorder.h - tracer/tracer.h + tracer/citrace.h mem_map.h memory.h memory_setup.h diff --git a/src/core/tracer/citrace.h b/src/core/tracer/citrace.h new file mode 100644 index 00000000..5deb6ce9 --- /dev/null +++ b/src/core/tracer/citrace.h @@ -0,0 +1,101 @@ +// Copyright 2015 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#pragma once + +#include + +namespace CiTrace { + +// NOTE: Things are stored in little-endian + +#pragma pack(1) + +struct CTHeader { + static const char* ExpectedMagicWord() { + return "CiTr"; + } + + static uint32_t ExpectedVersion() { + return 1; + } + + char magic[4]; + uint32_t version; + uint32_t header_size; + + struct { + // NOTE: Register range sizes are technically hardware-constants, but the actual limits + // aren't known. Hence we store the presumed limits along the offsets. + // Sizes are given in uint32_t units. + uint32_t gpu_registers; + uint32_t gpu_registers_size; + uint32_t lcd_registers; + uint32_t lcd_registers_size; + uint32_t pica_registers; + uint32_t pica_registers_size; + uint32_t default_attributes; + uint32_t default_attributes_size; + uint32_t vs_program_binary; + uint32_t vs_program_binary_size; + uint32_t vs_swizzle_data; + uint32_t vs_swizzle_data_size; + uint32_t vs_float_uniforms; + uint32_t vs_float_uniforms_size; + uint32_t gs_program_binary; + uint32_t gs_program_binary_size; + uint32_t gs_swizzle_data; + uint32_t gs_swizzle_data_size; + uint32_t gs_float_uniforms; + uint32_t gs_float_uniforms_size; + + // Other things we might want to store here: + // - Initial framebuffer data, maybe even a full copy of FCRAM/VRAM + // - Lookup tables for fragment lighting + // - Lookup tables for procedural textures + } initial_state_offsets; + + uint32_t stream_offset; + uint32_t stream_size; +}; + +enum CTStreamElementType : uint32_t { + FrameMarker = 0xE1, + MemoryLoad = 0xE2, + RegisterWrite = 0xE3, +}; + +struct CTMemoryLoad { + uint32_t file_offset; + uint32_t size; + uint32_t physical_address; + uint32_t pad; +}; + +struct CTRegisterWrite { + uint32_t physical_address; + + enum : uint32_t { + SIZE_8 = 0xD1, + SIZE_16 = 0xD2, + SIZE_32 = 0xD3, + SIZE_64 = 0xD4 + } size; + + // TODO: Make it clearer which bits of this member are used for sizes other than 32 bits + uint64_t value; +}; + +struct CTStreamElement { + CTStreamElementType type; + + union { + CTMemoryLoad memory_load; + CTRegisterWrite register_write; + }; +}; + +#pragma pack() + +} diff --git a/src/core/tracer/recorder.cpp b/src/core/tracer/recorder.cpp index 73ebdd38..c5251634 100644 --- a/src/core/tracer/recorder.cpp +++ b/src/core/tracer/recorder.cpp @@ -12,18 +12,20 @@ namespace CiTrace { -Recorder::Recorder(u32* gpu_registers, u32 gpu_registers_size, - u32* lcd_registers, u32 lcd_registers_size, - u32* pica_registers, u32 pica_registers_size, - u32* vs_program_binary, u32 vs_program_binary_size, - u32* vs_swizzle_data, u32 vs_swizzle_data_size, - u32* vs_float_uniforms, u32 vs_float_uniforms_size, - u32* gs_program_binary, u32 gs_program_binary_size, - u32* gs_swizzle_data, u32 gs_swizzle_data_size, - u32* gs_float_uniforms, u32 gs_float_uniforms_size) +Recorder::Recorder(u32* gpu_registers, u32 gpu_registers_size, + u32* lcd_registers, u32 lcd_registers_size, + u32* pica_registers, u32 pica_registers_size, + u32* default_attributes, u32 default_attributes_size, + u32* vs_program_binary, u32 vs_program_binary_size, + u32* vs_swizzle_data, u32 vs_swizzle_data_size, + u32* vs_float_uniforms, u32 vs_float_uniforms_size, + u32* gs_program_binary, u32 gs_program_binary_size, + u32* gs_swizzle_data, u32 gs_swizzle_data_size, + u32* gs_float_uniforms, u32 gs_float_uniforms_size) : gpu_registers(gpu_registers, gpu_registers + gpu_registers_size), lcd_registers(lcd_registers, lcd_registers + lcd_registers_size), pica_registers(pica_registers, pica_registers + pica_registers_size), + default_attributes(default_attributes, default_attributes + default_attributes_size), vs_program_binary(vs_program_binary, vs_program_binary + vs_program_binary_size), vs_swizzle_data(vs_swizzle_data, vs_swizzle_data + vs_swizzle_data_size), vs_float_uniforms(vs_float_uniforms, vs_float_uniforms + vs_float_uniforms_size), @@ -43,27 +45,29 @@ void Recorder::Finish(const std::string& filename) { // Calculate file offsets auto& initial = header.initial_state_offsets; - initial.gpu_registers_size = gpu_registers.size(); - initial.lcd_registers_size = lcd_registers.size(); - initial.pica_registers_size = pica_registers.size(); - initial.vs_program_binary_size = vs_program_binary.size(); - initial.vs_swizzle_data_size = vs_swizzle_data.size(); - initial.vs_float_uniforms_size = vs_float_uniforms.size(); - initial.gs_program_binary_size = gs_program_binary.size(); - initial.gs_swizzle_data_size = gs_swizzle_data.size(); - initial.gs_float_uniforms_size = gs_float_uniforms.size(); - header.stream_size = 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.vs_program_binary = initial.pica_registers + initial.pica_registers_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); + initial.gpu_registers_size = gpu_registers.size(); + initial.lcd_registers_size = lcd_registers.size(); + initial.pica_registers_size = pica_registers.size(); + initial.default_attributes_size = default_attributes.size(); + initial.vs_program_binary_size = vs_program_binary.size(); + initial.vs_swizzle_data_size = vs_swizzle_data.size(); + initial.vs_float_uniforms_size = vs_float_uniforms.size(); + initial.gs_program_binary_size = gs_program_binary.size(); + initial.gs_swizzle_data_size = gs_swizzle_data.size(); + initial.gs_float_uniforms_size = gs_float_uniforms.size(); + header.stream_size = 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) { @@ -103,9 +107,13 @@ void Recorder::Finish(const std::string& filename) { throw "Failed to write LCD registers"; written = file.WriteArray(pica_registers.data(), pica_registers.size()); - if (written != pica_registers.size() || file.Tell() != initial.vs_program_binary) + if (written != pica_registers.size() || file.Tell() != initial.default_attributes) throw "Failed to write Pica registers"; + written = file.WriteArray(default_attributes.data(), default_attributes.size()); + if (written != default_attributes.size() || file.Tell() != initial.vs_program_binary) + throw "Failed to write default vertex attributes"; + written = file.WriteArray(vs_program_binary.data(), vs_program_binary.size()); if (written != vs_program_binary.size() || file.Tell() != initial.vs_swizzle_data) throw "Failed to write vertex shader program binary"; diff --git a/src/core/tracer/recorder.h b/src/core/tracer/recorder.h index 8fec0a97..da77aac5 100644 --- a/src/core/tracer/recorder.h +++ b/src/core/tracer/recorder.h @@ -11,7 +11,7 @@ #include "common/common_types.h" -#include "tracer.h" +#include "citrace.h" namespace CiTrace { @@ -19,17 +19,19 @@ class Recorder { public: /** * Recorder constructor + * @param default_attributes Pointer to an array of 32-bit-aligned 24-bit floating point values. * @param vs_float_uniforms Pointer to an array of 32-bit-aligned 24-bit floating point values. */ - Recorder(u32* gpu_registers, u32 gpu_registers_size, - u32* lcd_registers, u32 lcd_registers_size, - u32* pica_registers, u32 pica_registers_size, - u32* vs_program_binary, u32 vs_program_binary_size, - u32* vs_swizzle_data, u32 vs_swizzle_data_size, - u32* vs_float_uniforms, u32 vs_float_uniforms_size, - u32* gs_program_binary, u32 gs_program_binary_size, - u32* gs_swizzle_data, u32 gs_swizzle_data_size, - u32* gs_float_uniforms, u32 gs_float_uniforms_size); + Recorder(u32* gpu_registers, u32 gpu_registers_size, + u32* lcd_registers, u32 lcd_registers_size, + u32* pica_registers, u32 pica_registers_size, + u32* default_attributes, u32 default_attributes_size, + u32* vs_program_binary, u32 vs_program_binary_size, + u32* vs_swizzle_data, u32 vs_swizzle_data_size, + u32* vs_float_uniforms, u32 vs_float_uniforms_size, + u32* gs_program_binary, u32 gs_program_binary_size, + u32* gs_swizzle_data, u32 gs_swizzle_data_size, + u32* gs_float_uniforms, u32 gs_float_uniforms_size); /// Finish recording of this Citrace and save it using the given filename. void Finish(const std::string& filename); @@ -56,6 +58,7 @@ private: std::vector gpu_registers; std::vector lcd_registers; std::vector pica_registers; + std::vector default_attributes; std::vector vs_program_binary; std::vector vs_swizzle_data; std::vector vs_float_uniforms; diff --git a/src/core/tracer/tracer.h b/src/core/tracer/tracer.h deleted file mode 100644 index 1545d743..00000000 --- a/src/core/tracer/tracer.h +++ /dev/null @@ -1,98 +0,0 @@ -// Copyright 2015 Citra Emulator Project -// Licensed under GPLv2 or any later version -// Refer to the license.txt file included. - -#pragma once - -#include - -namespace CiTrace { - -// NOTE: Things are stored in little-endian - -#pragma pack(1) - -struct CTHeader { - static const char* ExpectedMagicWord() { - return "CiTr"; - } - - static uint32_t ExpectedVersion() { - return 1; - } - - char magic[4]; - uint32_t version; - uint32_t header_size; - - struct { - // NOTE: Register range sizes are technically hardware-constants, but the actual limits - // aren't known. Hence we store the presumed limits along the offsets. - // Sizes are given in uint32_t units. - uint32_t gpu_registers; - uint32_t gpu_registers_size; - uint32_t lcd_registers; - uint32_t lcd_registers_size; - uint32_t pica_registers; - uint32_t pica_registers_size; - uint32_t vs_program_binary; - uint32_t vs_program_binary_size; - uint32_t vs_swizzle_data; - uint32_t vs_swizzle_data_size; - uint32_t vs_float_uniforms; - uint32_t vs_float_uniforms_size; - uint32_t gs_program_binary; - uint32_t gs_program_binary_size; - uint32_t gs_swizzle_data; - uint32_t gs_swizzle_data_size; - uint32_t gs_float_uniforms; - uint32_t gs_float_uniforms_size; - - // Other things we might want to store here: - // - Initial framebuffer data, maybe even a full copy of FCRAM/VRAM - // - Default vertex attributes - } initial_state_offsets; - - uint32_t stream_offset; - uint32_t stream_size; -}; - -enum CTStreamElementType : uint32_t { - FrameMarker = 0xE1, - MemoryLoad = 0xE2, - RegisterWrite = 0xE3, -}; - -struct CTMemoryLoad { - uint32_t file_offset; - uint32_t size; - uint32_t physical_address; - uint32_t pad; -}; - -struct CTRegisterWrite { - uint32_t physical_address; - - enum : uint32_t { - SIZE_8 = 0xD1, - SIZE_16 = 0xD2, - SIZE_32 = 0xD3, - SIZE_64 = 0xD4 - } size; - - // TODO: Make it clearer which bits of this member are used for sizes other than 32 bits - uint64_t value; -}; - -struct CTStreamElement { - CTStreamElementType type; - - union { - CTMemoryLoad memory_load; - CTRegisterWrite register_write; - }; -}; - -#pragma pack() - -} -- cgit v1.2.3 From 29abb11e8fbb6a78edf84496979ef946bf4e45a7 Mon Sep 17 00:00:00 2001 From: Tony Wasserka Date: Sun, 12 Jul 2015 03:20:19 +0200 Subject: CiTrace: Clean up initialization method. --- src/citra_qt/debugger/graphics_tracing.cpp | 24 +++++---- src/core/tracer/recorder.cpp | 81 ++++++++++++------------------ src/core/tracer/recorder.h | 35 ++++++------- 3 files changed, 61 insertions(+), 79 deletions(-) (limited to 'src/core/tracer') diff --git a/src/citra_qt/debugger/graphics_tracing.cpp b/src/citra_qt/debugger/graphics_tracing.cpp index 654df12a..3f20f149 100644 --- a/src/citra_qt/debugger/graphics_tracing.cpp +++ b/src/citra_qt/debugger/graphics_tracing.cpp @@ -12,6 +12,8 @@ #include #include +#include + #include "core/hw/gpu.h" #include "core/hw/lcd.h" @@ -76,15 +78,19 @@ void GraphicsTracingWidget::StartRecording() { for (unsigned comp = 0; comp < 3; ++comp) vs_float_uniforms[4 * i + comp] = nihstro::to_float24(Pica::g_state.vs.uniforms.f[i][comp].ToFloat32()); - auto recorder = new CiTrace::Recorder((u32*)&GPU::g_regs, sizeof(GPU::g_regs) / sizeof(u32), - (u32*)&LCD::g_regs, sizeof(LCD::g_regs) / sizeof(u32), - (u32*)&Pica::g_state.regs, sizeof(Pica::g_state.regs) / sizeof(u32), - default_attributes.data(), default_attributes.size(), - shader_binary.data(), shader_binary.size(), - swizzle_data.data(), swizzle_data.size(), - vs_float_uniforms.data(), vs_float_uniforms.size(), - nullptr, 0, nullptr, 0, nullptr, 0 // Geometry shader is not implemented yet, so submit dummy data for now - ); + CiTrace::Recorder::InitialState state; + std::copy_n((u32*)&GPU::g_regs, sizeof(GPU::g_regs) / sizeof(u32), std::back_inserter(state.gpu_registers)); + std::copy_n((u32*)&LCD::g_regs, sizeof(LCD::g_regs) / sizeof(u32), std::back_inserter(state.lcd_registers)); + std::copy_n((u32*)&Pica::g_state.regs, sizeof(Pica::g_state.regs) / sizeof(u32), std::back_inserter(state.pica_registers)); + boost::copy(default_attributes, std::back_inserter(state.default_attributes)); + boost::copy(shader_binary, std::back_inserter(state.vs_program_binary)); + boost::copy(swizzle_data, std::back_inserter(state.vs_swizzle_data)); + boost::copy(vs_float_uniforms, std::back_inserter(state.vs_float_uniforms)); + //boost::copy(TODO: Not implemented, std::back_inserter(state.gs_program_binary)); + //boost::copy(TODO: Not implemented, std::back_inserter(state.gs_swizzle_data)); + //boost::copy(TODO: Not implemented, std::back_inserter(state.gs_float_uniforms)); + + auto recorder = new CiTrace::Recorder(state); context->recorder = std::shared_ptr(recorder); emit SetStartTracingButtonEnabled(false); diff --git a/src/core/tracer/recorder.cpp b/src/core/tracer/recorder.cpp index c5251634..656706c0 100644 --- a/src/core/tracer/recorder.cpp +++ b/src/core/tracer/recorder.cpp @@ -12,26 +12,7 @@ namespace CiTrace { -Recorder::Recorder(u32* gpu_registers, u32 gpu_registers_size, - u32* lcd_registers, u32 lcd_registers_size, - u32* pica_registers, u32 pica_registers_size, - u32* default_attributes, u32 default_attributes_size, - u32* vs_program_binary, u32 vs_program_binary_size, - u32* vs_swizzle_data, u32 vs_swizzle_data_size, - u32* vs_float_uniforms, u32 vs_float_uniforms_size, - u32* gs_program_binary, u32 gs_program_binary_size, - u32* gs_swizzle_data, u32 gs_swizzle_data_size, - u32* gs_float_uniforms, u32 gs_float_uniforms_size) - : gpu_registers(gpu_registers, gpu_registers + gpu_registers_size), - lcd_registers(lcd_registers, lcd_registers + lcd_registers_size), - pica_registers(pica_registers, pica_registers + pica_registers_size), - default_attributes(default_attributes, default_attributes + default_attributes_size), - vs_program_binary(vs_program_binary, vs_program_binary + vs_program_binary_size), - vs_swizzle_data(vs_swizzle_data, vs_swizzle_data + vs_swizzle_data_size), - vs_float_uniforms(vs_float_uniforms, vs_float_uniforms + vs_float_uniforms_size), - gs_program_binary(gs_program_binary, gs_program_binary + gs_program_binary_size), - gs_swizzle_data(gs_swizzle_data, gs_swizzle_data + gs_swizzle_data_size), - gs_float_uniforms(gs_float_uniforms, gs_float_uniforms + gs_float_uniforms_size) { +Recorder::Recorder(const InitialState& initial_state) : initial_state(initial_state) { } @@ -45,16 +26,16 @@ void Recorder::Finish(const std::string& filename) { // Calculate file offsets auto& initial = header.initial_state_offsets; - initial.gpu_registers_size = gpu_registers.size(); - initial.lcd_registers_size = lcd_registers.size(); - initial.pica_registers_size = pica_registers.size(); - initial.default_attributes_size = default_attributes.size(); - initial.vs_program_binary_size = vs_program_binary.size(); - initial.vs_swizzle_data_size = vs_swizzle_data.size(); - initial.vs_float_uniforms_size = vs_float_uniforms.size(); - initial.gs_program_binary_size = gs_program_binary.size(); - initial.gs_swizzle_data_size = gs_swizzle_data.size(); - initial.gs_float_uniforms_size = gs_float_uniforms.size(); + initial.gpu_registers_size = initial_state.gpu_registers.size(); + initial.lcd_registers_size = initial_state.lcd_registers.size(); + initial.pica_registers_size = initial_state.pica_registers.size(); + initial.default_attributes_size = initial_state.default_attributes.size(); + initial.vs_program_binary_size = initial_state.vs_program_binary.size(); + initial.vs_swizzle_data_size = initial_state.vs_swizzle_data.size(); + initial.vs_float_uniforms_size = initial_state.vs_float_uniforms.size(); + initial.gs_program_binary_size = initial_state.gs_program_binary.size(); + initial.gs_swizzle_data_size = initial_state.gs_swizzle_data.size(); + initial.gs_float_uniforms_size = initial_state.gs_float_uniforms.size(); header.stream_size = stream.size(); initial.gpu_registers = sizeof(header); @@ -98,44 +79,44 @@ void Recorder::Finish(const std::string& filename) { throw "Failed to write header"; // Write initial state - written = file.WriteArray(gpu_registers.data(), gpu_registers.size()); - if (written != gpu_registers.size() || file.Tell() != initial.lcd_registers) + 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(lcd_registers.data(), lcd_registers.size()); - if (written != lcd_registers.size() || file.Tell() != initial.pica_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(pica_registers.data(), pica_registers.size()); - if (written != pica_registers.size() || file.Tell() != initial.default_attributes) + 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(default_attributes.data(), default_attributes.size()); - if (written != default_attributes.size() || file.Tell() != initial.vs_program_binary) + 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(vs_program_binary.data(), vs_program_binary.size()); - if (written != vs_program_binary.size() || file.Tell() != initial.vs_swizzle_data) + 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(vs_swizzle_data.data(), vs_swizzle_data.size()); - if (written != vs_swizzle_data.size() || file.Tell() != initial.vs_float_uniforms) + 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(vs_float_uniforms.data(), vs_float_uniforms.size()); - if (written != vs_float_uniforms.size() || file.Tell() != initial.gs_program_binary) + 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(gs_program_binary.data(), gs_program_binary.size()); - if (written != gs_program_binary.size() || file.Tell() != initial.gs_swizzle_data) + 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(gs_swizzle_data.data(), gs_swizzle_data.size()); - if (written != gs_swizzle_data.size() || file.Tell() != initial.gs_float_uniforms) + 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(gs_float_uniforms.data(), gs_float_uniforms.size()); - if (written != gs_float_uniforms.size() || file.Tell() != initial.gs_float_uniforms + sizeof(u32) * initial.gs_float_uniforms_size) + 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" diff --git a/src/core/tracer/recorder.h b/src/core/tracer/recorder.h index da77aac5..6e4b7001 100644 --- a/src/core/tracer/recorder.h +++ b/src/core/tracer/recorder.h @@ -17,21 +17,25 @@ namespace CiTrace { class Recorder { public: + struct InitialState { + std::vector gpu_registers; + std::vector lcd_registers; + std::vector pica_registers; + std::vector default_attributes; + std::vector vs_program_binary; + std::vector vs_swizzle_data; + std::vector vs_float_uniforms; + std::vector gs_program_binary; + std::vector gs_swizzle_data; + std::vector gs_float_uniforms; + }; + /** * Recorder constructor * @param default_attributes Pointer to an array of 32-bit-aligned 24-bit floating point values. * @param vs_float_uniforms Pointer to an array of 32-bit-aligned 24-bit floating point values. */ - Recorder(u32* gpu_registers, u32 gpu_registers_size, - u32* lcd_registers, u32 lcd_registers_size, - u32* pica_registers, u32 pica_registers_size, - u32* default_attributes, u32 default_attributes_size, - u32* vs_program_binary, u32 vs_program_binary_size, - u32* vs_swizzle_data, u32 vs_swizzle_data_size, - u32* vs_float_uniforms, u32 vs_float_uniforms_size, - u32* gs_program_binary, u32 gs_program_binary_size, - u32* gs_swizzle_data, u32 gs_swizzle_data_size, - u32* gs_float_uniforms, u32 gs_float_uniforms_size); + Recorder(const InitialState& initial_state); /// Finish recording of this Citrace and save it using the given filename. void Finish(const std::string& filename); @@ -55,16 +59,7 @@ public: private: // Initial state of recording start - std::vector gpu_registers; - std::vector lcd_registers; - std::vector pica_registers; - std::vector default_attributes; - std::vector vs_program_binary; - std::vector vs_swizzle_data; - std::vector vs_float_uniforms; - std::vector gs_program_binary; - std::vector gs_swizzle_data; - std::vector gs_float_uniforms; + InitialState initial_state; // Command stream struct StreamElement { -- cgit v1.2.3