N-archive/pineapple-src
1
0
Fork 0
Code Issues 5 Pull requests 2 Projects Releases Packages Wiki Activity

early-access version 3167

Browse source
This commit is contained in:
pineappleEA 2022-11-30 02:37:58 +01:00
parent c7b0ae563c
commit bfa57b3fe9
13 changed files with 69 additions and 99 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
README.md
View file

@ -1,7 +1,7 @@
yuzu emulator early access yuzu emulator early access
============= =============
This is the source code for early-access 3166. This is the source code for early-access 3167.
## Legal Notice ## Legal Notice

7
src/video_core/engines/engine_upload.cpp
View file

@ -49,10 +49,9 @@ void State::ProcessData(std::span<const u8> read_buffer) {
if (regs.line_count == 1) { if (regs.line_count == 1) {
rasterizer->AccelerateInlineToMemory(address, copy_size, read_buffer); rasterizer->AccelerateInlineToMemory(address, copy_size, read_buffer);
} else { } else {
for (u32 line = 0; line < regs.line_count; ++line) { for (size_t line = 0; line < regs.line_count; ++line) {
const GPUVAddr dest_line = address + static_cast<size_t>(line) * regs.dest.pitch; const GPUVAddr dest_line = address + line * regs.dest.pitch;
std::span<const u8> buffer(read_buffer.data() + std::span<const u8> buffer(read_buffer.data() + line * regs.line_length_in,
static_cast<size_t>(line) * regs.line_length_in,
regs.line_length_in); regs.line_length_in);
rasterizer->AccelerateInlineToMemory(dest_line, regs.line_length_in, buffer); rasterizer->AccelerateInlineToMemory(dest_line, regs.line_length_in, buffer);
} }

2
src/video_core/engines/engine_upload.h
View file

@ -39,7 +39,7 @@ struct Registers {
u32 y; u32 y;
GPUVAddr Address() const { GPUVAddr Address() const {
return static_cast<GPUVAddr>((static_cast<GPUVAddr>(address_high) << 32) | address_low); return (GPUVAddr{address_high} << 32) | GPUVAddr{address_low};
} }
u32 BlockWidth() const { u32 BlockWidth() const {

2
src/video_core/engines/fermi_2d.h
View file

@ -97,7 +97,7 @@ public:
u32 addr_lower; u32 addr_lower;
[[nodiscard]] constexpr GPUVAddr Address() const noexcept { [[nodiscard]] constexpr GPUVAddr Address() const noexcept {
return (static_cast<GPUVAddr>(addr_upper) << 32) | static_cast<GPUVAddr>(addr_lower); return (GPUVAddr{addr_upper} << 32) | GPUVAddr{addr_lower};
} }
}; };
static_assert(sizeof(Surface) == 0x28, "Surface has incorrect size"); static_assert(sizeof(Surface) == 0x28, "Surface has incorrect size");

6
src/video_core/engines/kepler_compute.cpp
View file

@ -50,11 +50,11 @@ void KeplerCompute::CallMultiMethod(u32 method, const u32* base_start, u32 amoun
u32 methods_pending) { u32 methods_pending) {
switch (method) { switch (method) {
case KEPLER_COMPUTE_REG_INDEX(data_upload): case KEPLER_COMPUTE_REG_INDEX(data_upload):
upload_state.ProcessData(base_start, static_cast<size_t>(amount)); upload_state.ProcessData(base_start, amount);
return; return;
default: default:
for (std::size_t i = 0; i < amount; i++) { for (u32 i = 0; i < amount; i++) {
CallMethod(method, base_start[i], methods_pending - static_cast<u32>(i) <= 1); CallMethod(method, base_start[i], methods_pending - i <= 1);
} }
break; break;
} }

14
src/video_core/engines/kepler_compute.h
View file

@ -68,7 +68,7 @@ public:
struct { struct {
u32 address; u32 address;
GPUVAddr Address() const { GPUVAddr Address() const {
return static_cast<GPUVAddr>((static_cast<GPUVAddr>(address) << 8)); return GPUVAddr{address} << 8;
} }
} launch_desc_loc; } launch_desc_loc;
@ -83,8 +83,7 @@ public:
u32 address_low; u32 address_low;
u32 limit; u32 limit;
GPUVAddr Address() const { GPUVAddr Address() const {
return static_cast<GPUVAddr>((static_cast<GPUVAddr>(address_high) << 32) | return (GPUVAddr{address_high} << 32) | GPUVAddr{address_low};
address_low);
} }
} tsc; } tsc;
@ -95,8 +94,7 @@ public:
u32 address_low; u32 address_low;
u32 limit; u32 limit;
GPUVAddr Address() const { GPUVAddr Address() const {
return static_cast<GPUVAddr>((static_cast<GPUVAddr>(address_high) << 32) | return (GPUVAddr{address_high} << 32) | GPUVAddr{address_low};
address_low);
} }
} tic; } tic;
@ -106,8 +104,7 @@ public:
u32 address_high; u32 address_high;
u32 address_low; u32 address_low;
GPUVAddr Address() const { GPUVAddr Address() const {
return static_cast<GPUVAddr>((static_cast<GPUVAddr>(address_high) << 32) | return (GPUVAddr{address_high} << 32) | GPUVAddr{address_low};
address_low);
} }
} code_loc; } code_loc;
@ -162,8 +159,7 @@ public:
BitField<15, 17, u32> size; BitField<15, 17, u32> size;
}; };
GPUVAddr Address() const { GPUVAddr Address() const {
return static_cast<GPUVAddr>((static_cast<GPUVAddr>(address_high.Value()) << 32) | return (GPUVAddr{address_high.Value()} << 32) | GPUVAddr{address_low};
address_low);
} }
}; };
std::array<ConstBufferConfig, NumConstBuffers> const_buffer_config; std::array<ConstBufferConfig, NumConstBuffers> const_buffer_config;

6
src/video_core/engines/kepler_memory.cpp
View file

@ -42,11 +42,11 @@ void KeplerMemory::CallMultiMethod(u32 method, const u32* base_start, u32 amount
u32 methods_pending) { u32 methods_pending) {
switch (method) { switch (method) {
case KEPLERMEMORY_REG_INDEX(data): case KEPLERMEMORY_REG_INDEX(data):
upload_state.ProcessData(base_start, static_cast<size_t>(amount)); upload_state.ProcessData(base_start, amount);
return; return;
default: default:
for (std::size_t i = 0; i < amount; i++) { for (u32 i = 0; i < amount; i++) {
CallMethod(method, base_start[i], methods_pending - static_cast<u32>(i) <= 1); CallMethod(method, base_start[i], methods_pending - i <= 1);
} }
break; break;
} }

12
src/video_core/engines/maxwell_3d.cpp
View file

@ -370,11 +370,11 @@ void Maxwell3D::CallMultiMethod(u32 method, const u32* base_start, u32 amount,
ProcessCBMultiData(base_start, amount); ProcessCBMultiData(base_start, amount);
break; break;
case MAXWELL3D_REG_INDEX(inline_data): case MAXWELL3D_REG_INDEX(inline_data):
upload_state.ProcessData(base_start, static_cast<size_t>(amount)); upload_state.ProcessData(base_start, amount);
return; return;
default: default:
for (std::size_t i = 0; i < amount; i++) { for (u32 i = 0; i < amount; i++) {
CallMethod(method, base_start[i], methods_pending - static_cast<u32>(i) <= 1); CallMethod(method, base_start[i], methods_pending - i <= 1);
} }
break; break;
} }
@ -652,12 +652,12 @@ void Maxwell3D::ProcessDeferredDraw() {
return; return;
} }
u32 method_count = static_cast<u32>(deferred_draw_method.size()); const auto method_count = deferred_draw_method.size();
u32 instance_count = 1; u32 instance_count = 1;
u32 vertex_buffer_count = 0; u32 vertex_buffer_count = 0;
u32 index_buffer_count = 0; u32 index_buffer_count = 0;
for (u32 index = 0; index < method_count; ++index) { for (size_t index = 0; index < method_count; ++index) {
u32 method = deferred_draw_method[index]; const u32 method = deferred_draw_method[index];
if (method == MAXWELL3D_REG_INDEX(vertex_buffer.count)) { if (method == MAXWELL3D_REG_INDEX(vertex_buffer.count)) {
instance_count = ++vertex_buffer_count; instance_count = ++vertex_buffer_count;
} else if (method == MAXWELL3D_REG_INDEX(index_buffer.count)) { } else if (method == MAXWELL3D_REG_INDEX(index_buffer.count)) {

79
src/video_core/engines/maxwell_3d.h
View file

@ -96,8 +96,7 @@ public:
u32 type; u32 type;
GPUVAddr Address() const { GPUVAddr Address() const {
return static_cast<GPUVAddr>((static_cast<GPUVAddr>(address_high) << 32) | return (GPUVAddr{address_high} << 32) | GPUVAddr{address_low};
address_low);
} }
}; };
@ -106,8 +105,7 @@ public:
u32 address_low; u32 address_low;
GPUVAddr Address() const { GPUVAddr Address() const {
return static_cast<GPUVAddr>((static_cast<GPUVAddr>(address_high) << 32) | return (GPUVAddr{address_high} << 32) | GPUVAddr{address_low};
address_low);
} }
}; };
@ -124,8 +122,7 @@ public:
Mode mode; Mode mode;
GPUVAddr Address() const { GPUVAddr Address() const {
return static_cast<GPUVAddr>((static_cast<GPUVAddr>(offset_high) << 32) | return (GPUVAddr{offset_high} << 32) | GPUVAddr{offset_low};
offset_low);
} }
}; };
@ -187,7 +184,7 @@ public:
default: default:
// Thresholds begin at 0x10 (1 << 4) // Thresholds begin at 0x10 (1 << 4)
// Threshold is in the range 0x1 to 0x13 // Threshold is in the range 0x1 to 0x13
return 1 << (4 + threshold.Value() - 1); return 1U << (4 + threshold.Value() - 1);
} }
} }
}; };
@ -468,8 +465,7 @@ public:
INSERT_PADDING_BYTES_NOINIT(0xC); INSERT_PADDING_BYTES_NOINIT(0xC);
GPUVAddr Address() const { GPUVAddr Address() const {
return static_cast<GPUVAddr>((static_cast<GPUVAddr>(address_high) << 32) | return (GPUVAddr{address_high} << 32) | GPUVAddr{address_low};
address_low);
} }
}; };
static_assert(sizeof(Buffer) == 0x20); static_assert(sizeof(Buffer) == 0x20);
@ -511,12 +507,11 @@ public:
u32 default_size_per_warp; u32 default_size_per_warp;
GPUVAddr Address() const { GPUVAddr Address() const {
return static_cast<GPUVAddr>((static_cast<GPUVAddr>(address_high) << 32) | return (GPUVAddr{address_high} << 32) | GPUVAddr{address_low};
address_low);
} }
u64 Size() const { u64 Size() const {
return (static_cast<u64>(size_high) << 32) | size_low; return (u64{size_high} << 32) | u64{size_low};
} }
}; };
@ -538,13 +533,11 @@ public:
u32 storage_limit_address_low; u32 storage_limit_address_low;
GPUVAddr StorageAddress() const { GPUVAddr StorageAddress() const {
return static_cast<GPUVAddr>((static_cast<GPUVAddr>(storage_address_high) << 32) | return (GPUVAddr{storage_address_high} << 32) | GPUVAddr{storage_address_low};
storage_address_low);
} }
GPUVAddr StorageLimitAddress() const { GPUVAddr StorageLimitAddress() const {
return static_cast<GPUVAddr>( return (GPUVAddr{storage_limit_address_high} << 32) |
(static_cast<GPUVAddr>(storage_limit_address_high) << 32) | GPUVAddr{storage_limit_address_low};
storage_limit_address_low);
} }
}; };
@ -829,11 +822,11 @@ public:
struct CompressionThresholdSamples { struct CompressionThresholdSamples {
u32 samples; u32 samples;
u32 Samples() { u32 Samples() const {
if (samples == 0) { if (samples == 0) {
return 0; return 0;
} }
return 1 << (samples - 1); return 1U << (samples - 1);
} }
}; };
@ -1138,8 +1131,7 @@ public:
INSERT_PADDING_BYTES_NOINIT(0x18); INSERT_PADDING_BYTES_NOINIT(0x18);
GPUVAddr Address() const { GPUVAddr Address() const {
return static_cast<GPUVAddr>((static_cast<GPUVAddr>(address_high) << 32) | return (GPUVAddr{address_high} << 32) | GPUVAddr{address_low};
address_low);
} }
}; };
static_assert(sizeof(RenderTargetConfig) == 0x40); static_assert(sizeof(RenderTargetConfig) == 0x40);
@ -1482,8 +1474,7 @@ public:
u32 address_low; u32 address_low;
GPUVAddr Address() const { GPUVAddr Address() const {
return static_cast<GPUVAddr>((static_cast<GPUVAddr>(address_high) << 32) | return (GPUVAddr{address_high} << 32) | GPUVAddr{address_low};
address_low);
} }
}; };
@ -1533,8 +1524,7 @@ public:
u32 address_low; u32 address_low;
GPUVAddr Address() const { GPUVAddr Address() const {
return static_cast<GPUVAddr>((static_cast<GPUVAddr>(address_high) << 32) | return (GPUVAddr{address_high} << 32) | GPUVAddr{address_low};
address_low);
} }
}; };
@ -1561,8 +1551,7 @@ public:
u32 array_pitch; u32 array_pitch;
GPUVAddr Address() const { GPUVAddr Address() const {
return static_cast<GPUVAddr>((static_cast<GPUVAddr>(address_high) << 32) | return (GPUVAddr{address_high} << 32) | GPUVAddr{address_low};
address_low);
} }
}; };
@ -1910,8 +1899,7 @@ public:
Mode mode; Mode mode;
GPUVAddr Address() const { GPUVAddr Address() const {
return static_cast<GPUVAddr>((static_cast<GPUVAddr>(address_high) << 32) | return (GPUVAddr{address_high} << 32) | GPUVAddr{address_low};
address_low);
} }
}; };
@ -1921,8 +1909,7 @@ public:
u32 limit; u32 limit;
GPUVAddr Address() const { GPUVAddr Address() const {
return static_cast<GPUVAddr>((static_cast<GPUVAddr>(address_high) << 32) | return (GPUVAddr{address_high} << 32) | GPUVAddr{address_low};
address_low);
} }
}; };
@ -1932,8 +1919,7 @@ public:
u32 limit; u32 limit;
GPUVAddr Address() const { GPUVAddr Address() const {
return static_cast<GPUVAddr>((static_cast<GPUVAddr>(address_high) << 32) | return (GPUVAddr{address_high} << 32) | GPUVAddr{address_low};
address_low);
} }
}; };
@ -1981,8 +1967,7 @@ public:
u32 address_low; u32 address_low;
GPUVAddr Address() const { GPUVAddr Address() const {
return static_cast<GPUVAddr>((static_cast<GPUVAddr>(address_high) << 32) | return (GPUVAddr{address_high} << 32) | GPUVAddr{address_low};
address_low);
} }
}; };
@ -2027,8 +2012,7 @@ public:
u32 address_low; u32 address_low;
GPUVAddr Address() const { GPUVAddr Address() const {
return static_cast<GPUVAddr>((static_cast<GPUVAddr>(address_high) << 32) | return (GPUVAddr{address_high} << 32) | GPUVAddr{address_low};
address_low);
} }
}; };
@ -2224,19 +2208,16 @@ public:
} }
GPUVAddr StartAddress() const { GPUVAddr StartAddress() const {
return static_cast<GPUVAddr>((static_cast<GPUVAddr>(start_addr_high) << 32) | return (GPUVAddr{start_addr_high} << 32) | GPUVAddr{start_addr_low};
start_addr_low);
} }
GPUVAddr EndAddress() const { GPUVAddr EndAddress() const {
return static_cast<GPUVAddr>((static_cast<GPUVAddr>(limit_addr_high) << 32) | return (GPUVAddr{limit_addr_high} << 32) | GPUVAddr{limit_addr_low};
limit_addr_low);
} }
/// Adjust the index buffer offset so it points to the first desired index. /// Adjust the index buffer offset so it points to the first desired index.
GPUVAddr IndexStart() const { GPUVAddr IndexStart() const {
return StartAddress() + return StartAddress() + size_t{first} * size_t{FormatSizeInBytes()};
static_cast<size_t>(first) * static_cast<size_t>(FormatSizeInBytes());
} }
}; };
@ -2464,8 +2445,7 @@ public:
} query; } query;
GPUVAddr Address() const { GPUVAddr Address() const {
return static_cast<GPUVAddr>((static_cast<GPUVAddr>(address_high) << 32) | return (GPUVAddr{address_high} << 32) | GPUVAddr{address_low};
address_low);
} }
}; };
@ -2479,8 +2459,7 @@ public:
u32 frequency; u32 frequency;
GPUVAddr Address() const { GPUVAddr Address() const {
return static_cast<GPUVAddr>((static_cast<GPUVAddr>(address_high) << 32) | return (GPUVAddr{address_high} << 32) | GPUVAddr{address_low};
address_low);
} }
bool IsEnabled() const { bool IsEnabled() const {
@ -2494,8 +2473,7 @@ public:
u32 address_low; u32 address_low;
GPUVAddr Address() const { GPUVAddr Address() const {
return static_cast<GPUVAddr>((static_cast<GPUVAddr>(address_high) << 32) | return (GPUVAddr{address_high} << 32) | GPUVAddr{address_low};
address_low);
} }
}; };
static_assert(sizeof(VertexStreamLimit) == 0x8); static_assert(sizeof(VertexStreamLimit) == 0x8);
@ -2543,8 +2521,7 @@ public:
std::array<u32, NumCBData> buffer; std::array<u32, NumCBData> buffer;
GPUVAddr Address() const { GPUVAddr Address() const {
return static_cast<GPUVAddr>((static_cast<GPUVAddr>(address_high) << 32) | return (GPUVAddr{address_high} << 32) | GPUVAddr{address_low};
address_low);
} }
}; };

14
src/video_core/engines/maxwell_dma.cpp
View file

@ -41,8 +41,8 @@ void MaxwellDMA::CallMethod(u32 method, u32 method_argument, bool is_last_call)
void MaxwellDMA::CallMultiMethod(u32 method, const u32* base_start, u32 amount, void MaxwellDMA::CallMultiMethod(u32 method, const u32* base_start, u32 amount,
u32 methods_pending) { u32 methods_pending) {
for (size_t i = 0; i < amount; ++i) { for (u32 i = 0; i < amount; ++i) {
CallMethod(method, base_start[i], methods_pending - static_cast<u32>(i) <= 1); CallMethod(method, base_start[i], methods_pending - i <= 1);
} }
} }
@ -94,14 +94,14 @@ void MaxwellDMA::Launch() {
reinterpret_cast<u8*>(tmp_buffer.data()), reinterpret_cast<u8*>(tmp_buffer.data()),
regs.line_length_in * sizeof(u32)); regs.line_length_in * sizeof(u32));
} else { } else {
auto convert_linear_2_blocklinear_addr = [](u64 address) { const auto convert_linear_2_blocklinear_addr = [](u64 address) {
return (address & ~0x1f0ULL) | ((address & 0x40) >> 2) | ((address & 0x10) << 1) | return (address & ~0x1f0ULL) | ((address & 0x40) >> 2) | ((address & 0x10) << 1) |
((address & 0x180) >> 1) | ((address & 0x20) << 3); ((address & 0x180) >> 1) | ((address & 0x20) << 3);
}; };
auto src_kind = memory_manager.GetPageKind(regs.offset_in); const auto src_kind = memory_manager.GetPageKind(regs.offset_in);
auto dst_kind = memory_manager.GetPageKind(regs.offset_out); const auto dst_kind = memory_manager.GetPageKind(regs.offset_out);
const bool is_src_pitch = IsPitchKind(static_cast<PTEKind>(src_kind)); const bool is_src_pitch = IsPitchKind(src_kind);
const bool is_dst_pitch = IsPitchKind(static_cast<PTEKind>(dst_kind)); const bool is_dst_pitch = IsPitchKind(dst_kind);
if (!is_src_pitch && is_dst_pitch) { if (!is_src_pitch && is_dst_pitch) {
UNIMPLEMENTED_IF(regs.line_length_in % 16 != 0); UNIMPLEMENTED_IF(regs.line_length_in % 16 != 0);
UNIMPLEMENTED_IF(regs.offset_in % 16 != 0); UNIMPLEMENTED_IF(regs.offset_in % 16 != 0);

6
src/video_core/engines/puller.cpp
View file

@ -31,7 +31,7 @@ void Puller::ProcessBindMethod(const MethodCall& method_call) {
LOG_DEBUG(HW_GPU, "Binding subchannel {} to engine {}", method_call.subchannel, LOG_DEBUG(HW_GPU, "Binding subchannel {} to engine {}", method_call.subchannel,
method_call.argument); method_call.argument);
const auto engine_id = static_cast<EngineID>(method_call.argument); const auto engine_id = static_cast<EngineID>(method_call.argument);
bound_engines[method_call.subchannel] = static_cast<EngineID>(engine_id); bound_engines[method_call.subchannel] = engine_id;
switch (engine_id) { switch (engine_id) {
case EngineID::FERMI_TWOD_A: case EngineID::FERMI_TWOD_A:
dma_pusher.BindSubchannel(channel_state.fermi_2d.get(), method_call.subchannel); dma_pusher.BindSubchannel(channel_state.fermi_2d.get(), method_call.subchannel);
@ -285,12 +285,12 @@ void Puller::CallMultiMethod(u32 method, u32 subchannel, const u32* base_start,
if (ExecuteMethodOnEngine(method)) { if (ExecuteMethodOnEngine(method)) {
CallEngineMultiMethod(method, subchannel, base_start, amount, methods_pending); CallEngineMultiMethod(method, subchannel, base_start, amount, methods_pending);
} else { } else {
for (std::size_t i = 0; i < amount; i++) { for (u32 i = 0; i < amount; i++) {
CallPullerMethod(MethodCall{ CallPullerMethod(MethodCall{
method, method,
base_start[i], base_start[i],
subchannel, subchannel,
methods_pending - static_cast<u32>(i), methods_pending - i,
}); });
} }
} }

6
src/video_core/host1x/syncpoint_manager.cpp
View file

@ -34,7 +34,7 @@ SyncpointManager::ActionHandle SyncpointManager::RegisterAction(
} }
void SyncpointManager::DeregisterAction(std::list<RegisteredAction>& action_storage, void SyncpointManager::DeregisterAction(std::list<RegisteredAction>& action_storage,
ActionHandle& handle) { const ActionHandle& handle) {
std::unique_lock lk(guard); std::unique_lock lk(guard);
// We want to ensure the iterator still exists prior to erasing it // We want to ensure the iterator still exists prior to erasing it
@ -49,11 +49,11 @@ void SyncpointManager::DeregisterAction(std::list<RegisteredAction>& action_stor
} }
} }
void SyncpointManager::DeregisterGuestAction(u32 syncpoint_id, ActionHandle& handle) { void SyncpointManager::DeregisterGuestAction(u32 syncpoint_id, const ActionHandle& handle) {
DeregisterAction(guest_action_storage[syncpoint_id], handle); DeregisterAction(guest_action_storage[syncpoint_id], handle);
} }
void SyncpointManager::DeregisterHostAction(u32 syncpoint_id, ActionHandle& handle) { void SyncpointManager::DeregisterHostAction(u32 syncpoint_id, const ActionHandle& handle) {
DeregisterAction(host_action_storage[syncpoint_id], handle); DeregisterAction(host_action_storage[syncpoint_id], handle);
} }

12
src/video_core/host1x/syncpoint_manager.h
View file

@ -36,21 +36,19 @@ public:
template <typename Func> template <typename Func>
ActionHandle RegisterGuestAction(u32 syncpoint_id, u32 expected_value, Func&& action) { ActionHandle RegisterGuestAction(u32 syncpoint_id, u32 expected_value, Func&& action) {
std::function<void()> func(action);
return RegisterAction(syncpoints_guest[syncpoint_id], guest_action_storage[syncpoint_id], return RegisterAction(syncpoints_guest[syncpoint_id], guest_action_storage[syncpoint_id],
expected_value, std::move(func)); expected_value, std::move(action));
} }
template <typename Func> template <typename Func>
ActionHandle RegisterHostAction(u32 syncpoint_id, u32 expected_value, Func&& action) { ActionHandle RegisterHostAction(u32 syncpoint_id, u32 expected_value, Func&& action) {
std::function<void()> func(action);
return RegisterAction(syncpoints_host[syncpoint_id], host_action_storage[syncpoint_id], return RegisterAction(syncpoints_host[syncpoint_id], host_action_storage[syncpoint_id],
expected_value, std::move(func)); expected_value, std::move(action));
} }
void DeregisterGuestAction(u32 syncpoint_id, ActionHandle& handle); void DeregisterGuestAction(u32 syncpoint_id, const ActionHandle& handle);
void DeregisterHostAction(u32 syncpoint_id, ActionHandle& handle); void DeregisterHostAction(u32 syncpoint_id, const ActionHandle& handle);
void IncrementGuest(u32 syncpoint_id); void IncrementGuest(u32 syncpoint_id);
@ -76,7 +74,7 @@ private:
std::list<RegisteredAction>& action_storage, u32 expected_value, std::list<RegisteredAction>& action_storage, u32 expected_value,
std::function<void()>&& action); std::function<void()>&& action);
void DeregisterAction(std::list<RegisteredAction>& action_storage, ActionHandle& handle); void DeregisterAction(std::list<RegisteredAction>& action_storage, const ActionHandle& handle);
void Wait(std::atomic<u32>& syncpoint, std::condition_variable& wait_cv, u32 expected_value); void Wait(std::atomic<u32>& syncpoint, std::condition_variable& wait_cv, u32 expected_value);