1
0
Fork 0
forked from suyu/suyu

GPU: Store uploaded GPU macros and keep track of the number of method parameters.

This commit is contained in:
Subv 2018-03-18 04:17:10 -05:00
parent 7ac8657432
commit aa586fa268
4 changed files with 74 additions and 27 deletions

View file

@ -24,12 +24,37 @@ namespace Tegra {
enum class BufferMethods { enum class BufferMethods {
BindObject = 0, BindObject = 0,
SetGraphMacroCode = 0x45,
SetGraphMacroCodeArg = 0x46,
SetGraphMacroEntry = 0x47,
CountBufferMethods = 0x100, CountBufferMethods = 0x100,
}; };
void GPU::WriteReg(u32 method, u32 subchannel, u32 value) { void GPU::WriteReg(u32 method, u32 subchannel, u32 value, u32 remaining_params) {
LOG_WARNING(HW_GPU, "Processing method %08X on subchannel %u value %08X", method, subchannel, LOG_WARNING(HW_GPU, "Processing method %08X on subchannel %u value %08X remaining params %u",
value); method, subchannel, value, remaining_params);
if (method == static_cast<u32>(BufferMethods::SetGraphMacroEntry)) {
// Prepare to upload a new macro, reset the upload counter.
LOG_DEBUG(HW_GPU, "Uploading GPU macro %08X", value);
current_macro_entry = value;
current_macro_code.clear();
return;
}
if (method == static_cast<u32>(BufferMethods::SetGraphMacroCodeArg)) {
// Append a new code word to the current macro.
current_macro_code.push_back(value);
// There are no more params remaining, submit the code to the 3D engine.
if (remaining_params == 0) {
maxwell_3d->SubmitMacroCode(current_macro_entry, std::move(current_macro_code));
current_macro_entry = InvalidGraphMacroEntry;
current_macro_code.clear();
}
return;
}
if (method == static_cast<u32>(BufferMethods::BindObject)) { if (method == static_cast<u32>(BufferMethods::BindObject)) {
// Bind the current subchannel to the desired engine id. // Bind the current subchannel to the desired engine id.
@ -54,7 +79,7 @@ void GPU::WriteReg(u32 method, u32 subchannel, u32 value) {
fermi_2d->WriteReg(method, value); fermi_2d->WriteReg(method, value);
break; break;
case EngineID::MAXWELL_B: case EngineID::MAXWELL_B:
maxwell_3d->WriteReg(method, value); maxwell_3d->WriteReg(method, value, remaining_params);
break; break;
case EngineID::MAXWELL_COMPUTE_B: case EngineID::MAXWELL_COMPUTE_B:
maxwell_compute->WriteReg(method, value); maxwell_compute->WriteReg(method, value);
@ -78,7 +103,8 @@ void GPU::ProcessCommandList(GPUVAddr address, u32 size) {
case SubmissionMode::Increasing: { case SubmissionMode::Increasing: {
// Increase the method value with each argument. // Increase the method value with each argument.
for (unsigned i = 0; i < header.arg_count; ++i) { for (unsigned i = 0; i < header.arg_count; ++i) {
WriteReg(header.method + i, header.subchannel, Memory::Read32(current_addr)); WriteReg(header.method + i, header.subchannel, Memory::Read32(current_addr),
header.arg_count - i - 1);
current_addr += sizeof(u32); current_addr += sizeof(u32);
} }
break; break;
@ -87,31 +113,31 @@ void GPU::ProcessCommandList(GPUVAddr address, u32 size) {
case SubmissionMode::NonIncreasing: { case SubmissionMode::NonIncreasing: {
// Use the same method value for all arguments. // Use the same method value for all arguments.
for (unsigned i = 0; i < header.arg_count; ++i) { for (unsigned i = 0; i < header.arg_count; ++i) {
WriteReg(header.method, header.subchannel, Memory::Read32(current_addr)); WriteReg(header.method, header.subchannel, Memory::Read32(current_addr),
header.arg_count - i - 1);
current_addr += sizeof(u32); current_addr += sizeof(u32);
} }
break; break;
} }
case SubmissionMode::IncreaseOnce: { case SubmissionMode::IncreaseOnce: {
ASSERT(header.arg_count.Value() >= 1); ASSERT(header.arg_count.Value() >= 1);
// Use the original method for the first argument and then the next method for all other // Use the original method for the first argument and then the next method for all other
// arguments. // arguments.
WriteReg(header.method, header.subchannel, Memory::Read32(current_addr),
header.arg_count - 1);
current_addr += sizeof(u32);
// Process this command as a method call instead of a register write. Gather for (unsigned i = 1; i < header.arg_count; ++i) {
// all the parameters first and then pass them at once to the CallMethod function. WriteReg(header.method + 1, header.subchannel, Memory::Read32(current_addr),
std::vector<u32> parameters(header.arg_count); header.arg_count - i - 1);
for (unsigned i = 0; i < header.arg_count; ++i) {
parameters[i] = Memory::Read32(current_addr);
current_addr += sizeof(u32); current_addr += sizeof(u32);
} }
CallMethod(header.method, header.subchannel, parameters);
break; break;
} }
case SubmissionMode::Inline: { case SubmissionMode::Inline: {
// The register value is stored in the bits 16-28 as an immediate // The register value is stored in the bits 16-28 as an immediate
WriteReg(header.method, header.subchannel, header.inline_data); WriteReg(header.method, header.subchannel, header.inline_data, 0);
break; break;
} }
default: default:

View file

@ -17,14 +17,21 @@ const std::unordered_map<u32, Maxwell3D::MethodInfo> Maxwell3D::method_handlers
Maxwell3D::Maxwell3D(MemoryManager& memory_manager) : memory_manager(memory_manager) {} Maxwell3D::Maxwell3D(MemoryManager& memory_manager) : memory_manager(memory_manager) {}
void Maxwell3D::AttemptMethodCall(u32 method, const std::vector<u32>& parameters) { void Maxwell3D::SubmitMacroCode(u32 entry, std::vector<u32> code) {
uploaded_macros[entry * 2 + MacroRegistersStart] = std::move(code);
}
void Maxwell3D::CallMacroMethod(u32 method, const std::vector<u32>& parameters) {
// TODO(Subv): Write an interpreter for the macros uploaded via registers 0x45 and 0x47 // TODO(Subv): Write an interpreter for the macros uploaded via registers 0x45 and 0x47
// The requested macro must have been uploaded already.
ASSERT_MSG(uploaded_macros.find(method) != uploaded_macros.end(), "Macro %08X was not uploaded",
method);
auto itr = method_handlers.find(method); auto itr = method_handlers.find(method);
ASSERT_MSG(itr != method_handlers.end(), "Unhandled method call %08X", method); ASSERT_MSG(itr != method_handlers.end(), "Unhandled method call %08X", method);
// Only execute the macro handler once we've been fed the expected number of parameters. ASSERT(itr->second.arguments == parameters.size());
if (itr->second.arguments != parameters.size())
return;
(this->*itr->second.handler)(parameters); (this->*itr->second.handler)(parameters);
@ -33,7 +40,7 @@ void Maxwell3D::AttemptMethodCall(u32 method, const std::vector<u32>& parameters
macro_params.clear(); macro_params.clear();
} }
void Maxwell3D::WriteReg(u32 method, u32 value) { void Maxwell3D::WriteReg(u32 method, u32 value, u32 remaining_params) {
ASSERT_MSG(method < Regs::NUM_REGS, ASSERT_MSG(method < Regs::NUM_REGS,
"Invalid Maxwell3D register, increase the size of the Regs structure"); "Invalid Maxwell3D register, increase the size of the Regs structure");
@ -56,8 +63,10 @@ void Maxwell3D::WriteReg(u32 method, u32 value) {
macro_params.push_back(value); macro_params.push_back(value);
// Try to call the macro with the current number of parameters. // Call the macro when there are no more parameters in the command buffer
AttemptMethodCall(executing_macro, macro_params); if (remaining_params == 0) {
CallMacroMethod(executing_macro, macro_params);
}
return; return;
} }

View file

@ -21,7 +21,10 @@ public:
~Maxwell3D() = default; ~Maxwell3D() = default;
/// Write the value to the register identified by method. /// Write the value to the register identified by method.
void WriteReg(u32 method, u32 value); void WriteReg(u32 method, u32 value, u32 remaining_params);
/// Uploads the code for a GPU macro program associated with the specified entry.
void SubmitMacroCode(u32 entry, std::vector<u32> code);
/// Register structure of the Maxwell3D engine. /// Register structure of the Maxwell3D engine.
/// TODO(Subv): This structure will need to be made bigger as more registers are discovered. /// TODO(Subv): This structure will need to be made bigger as more registers are discovered.
@ -198,18 +201,19 @@ public:
private: private:
MemoryManager& memory_manager; MemoryManager& memory_manager;
std::unordered_map<u32, std::vector<u32>> uploaded_macros;
/// Macro method that is currently being executed / being fed parameters. /// Macro method that is currently being executed / being fed parameters.
u32 executing_macro = 0; u32 executing_macro = 0;
/// Parameters that have been submitted to the macro call so far. /// Parameters that have been submitted to the macro call so far.
std::vector<u32> macro_params; std::vector<u32> macro_params;
/** /**
* Attempts a method call to this engine. Will return without doing anything if the number of * Call a macro on this engine.
* parameters doesn't match what is expected for the method.
* @param method Method to call * @param method Method to call
* @param parameters Arguments to the method call * @param parameters Arguments to the method call
*/ */
void AttemptMethodCall(u32 method, const std::vector<u32>& parameters); void CallMacroMethod(u32 method, const std::vector<u32>& parameters);
/// Handles a write to the QUERY_GET register. /// Handles a write to the QUERY_GET register.
void ProcessQueryGet(); void ProcessQueryGet();

View file

@ -6,6 +6,7 @@
#include <memory> #include <memory>
#include <unordered_map> #include <unordered_map>
#include <vector>
#include "common/common_types.h" #include "common/common_types.h"
#include "video_core/engines/fermi_2d.h" #include "video_core/engines/fermi_2d.h"
#include "video_core/engines/maxwell_3d.h" #include "video_core/engines/maxwell_3d.h"
@ -38,8 +39,10 @@ public:
std::unique_ptr<MemoryManager> memory_manager; std::unique_ptr<MemoryManager> memory_manager;
private: private:
static constexpr u32 InvalidGraphMacroEntry = 0xFFFFFFFF;
/// Writes a single register in the engine bound to the specified subchannel /// Writes a single register in the engine bound to the specified subchannel
void WriteReg(u32 method, u32 subchannel, u32 value); void WriteReg(u32 method, u32 subchannel, u32 value, u32 remaining_params);
/// Mapping of command subchannels to their bound engine ids. /// Mapping of command subchannels to their bound engine ids.
std::unordered_map<u32, EngineID> bound_engines; std::unordered_map<u32, EngineID> bound_engines;
@ -50,6 +53,11 @@ private:
std::unique_ptr<Engines::Fermi2D> fermi_2d; std::unique_ptr<Engines::Fermi2D> fermi_2d;
/// Compute engine /// Compute engine
std::unique_ptr<Engines::MaxwellCompute> maxwell_compute; std::unique_ptr<Engines::MaxwellCompute> maxwell_compute;
/// Entry of the macro that is currently being uploaded
u32 current_macro_entry = InvalidGraphMacroEntry;
/// Code being uploaded for the current macro
std::vector<u32> current_macro_code;
}; };
} // namespace Tegra } // namespace Tegra