Mirrored_Repos/LookingGlass
1
0
Fork 0
mirror of https://github.com/gnif/LookingGlass.git synced 2026-08-22 15:11:31 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

[idd] transport: fan out frame publication

Browse Source
This commit is contained in:
Geoffrey McRae
2026-08-12 19:31:47 +10:00
parent 656b0995f6
commit 8792c3c446
21 changed files with 3368 additions and 1056 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1025
idd/LGIdd/transport/CFrameHub.cpp
View File

File diff suppressed because it is too large Load Diff

182
idd/LGIdd/transport/CFrameHub.h
View File

@@ -25,81 +25,147 @@
#include "transport/IFrameTransport.h"
#include "transport/ITransport.h"
#include <vector>
#include <atomic>
class CFrameHub final : public IFrameTransport
{
private:
static const unsigned MAX_SLOTS = 1024;
struct Slot
struct Sink
{
uint64_t serial = 0;
bool committed = false;
bool completionPending = false;
bool completionSucceeded = false;
struct ResourceLane
{
uint8_t * mem = nullptr;
uint64_t heapOffset = 0;
unsigned localSlot = 0;
bool direct = false;
bool valid = false;
bool busy = false;
};
CSRWLock callLock;
IFrameSink * target = nullptr;
HANDLE drained = nullptr;
std::atomic<unsigned> outstanding = 0;
std::atomic_bool active = false;
std::atomic<BackendId> backend = 0;
std::atomic<uint32_t> epoch = 0;
bool reserved = false;
bool primary = false;
bool needsFullCopy = true;
uint64_t lastContent = 0;
uint64_t blockedContent = 0;
size_t blockedFrameSize = 0;
bool blockedAllocation = false;
unsigned pitch = 0;
unsigned width = 0;
unsigned height = 0;
DXGI_FORMAT format = DXGI_FORMAT_UNKNOWN;
FrameType frameType = FRAME_TYPE_INVALID;
ResourceLane lanes[FRAME_SINK_BUFFERS] = {};
};
mutable CSRWLock m_lock;
IFrameSink * m_sink = nullptr;
BackendId m_backend = 0;
uint32_t m_epoch = 0;
uint64_t m_nextSerial = 0;
std::vector<Slot> m_slots;
struct BatchTarget
{
Sink * sink = nullptr;
BackendId backend = 0;
uint32_t epoch = 0;
unsigned localSlot = 0;
unsigned resourceLane = 0;
CFrameScheduler::Schedule schedule = {};
CFrameScheduler::Schedule deliverySchedule = {};
uint64_t content = 0;
unsigned pitch = 0;
unsigned width = 0;
unsigned height = 0;
DXGI_FORMAT format = DXGI_FORMAT_UNKNOWN;
FrameType frameType = FRAME_TYPE_INVALID;
bool periodic = false;
bool published = false;
bool delivered = false;
bool submitted = false;
bool committed = false;
bool completionPending = false;
bool completionSucceeded = false;
bool releasePending = false;
bool active = false;
};
bool Valid(const FrameToken& token) const;
void Invalidate(const FrameToken& token);
struct Batch
{
CSRWLock lock;
uint64_t serial = 0;
unsigned count = 0;
bool active = false;
BatchTarget targets[FRAME_MAX_SINKS] = {};
};
struct SinkRef
{
Sink * sink;
unsigned index;
bool primary;
};
mutable CSRWLock m_listLock;
Sink m_sinks[FRAME_MAX_SINKS];
Batch m_batches[FRAME_BATCHES];
std::atomic<uint64_t> m_nextSerial = 0;
std::atomic<uint64_t> m_nextContent = 0;
std::atomic<uint64_t> m_newestContent = 0;
HANDLE m_wakeEvent = nullptr;
unsigned Snapshot(SinkRef refs[FRAME_MAX_SINKS]) const;
bool BatchValid(const Batch& batch, const FrameBatchToken& token) const;
void ReleaseTarget(Batch& batch, BatchTarget& target);
void CompleteTarget(Batch& batch, BatchTarget& target, bool succeeded);
public:
bool Bind(BackendId backend, uint32_t epoch, IFrameSink& sink);
CFrameHub();
~CFrameHub() override;
CFrameHub(const CFrameHub&) = delete;
CFrameHub& operator=(const CFrameHub&) = delete;
bool Bind(BackendId backend, uint32_t epoch, bool primary,
IFrameSink& sink);
void Unbind(BackendId backend, uint32_t epoch);
size_t GetMaxFrameSize() const override;
bool FrameBufferAvailable(const CFrameScheduler::Schedule& schedule,
bool allowReadyReplacement = true) override;
bool HasPublishedFrame() const override;
void ProcessDeliveries() override;
bool GetPendingDeliveryTarget(uint64_t now, uint64_t& target) override;
bool RetryPendingDelivery(uint64_t now, bool& retry) override;
PreparedFrameBuffer PrepareFrameBuffer(unsigned pitch,
uint64_t NextContentSerial() override;
void FrameProductReady(uint64_t contentSerial) override;
bool NeedsFrame() const override;
bool GetFramePlan(
uint64_t now, bool productReady, FramePlan& plan) override;
bool GetImmediateFramePlan(
uint64_t now, FramePlan& plan) override;
void MissFramePlan(const FramePlan& plan, uint64_t now) override;
bool PrepareFrameBatch(const FramePlan& plan,
uint64_t contentSerial, unsigned pitch, size_t frameSize,
const D12FrameFormat& srcFormat, const D12FrameFormat& dstFormat,
const RECT * dirtyRects, unsigned nbDirtyRects,
const CFrameScheduler::Schedule& schedule,
bool allowReadyReplacement = true) override;
bool PublishFrameBuffer(const FrameToken& token,
const CFrameScheduler::Schedule& schedule,
bool& deliveredToOwner) override;
bool RepublishFrameBuffer(
const CFrameScheduler::Schedule& schedule) override;
bool TryFrameSubmitted(const FrameToken& token,
const CFrameScheduler::Schedule& schedule) override;
void CommitFrameBuffer(const FrameToken& token,
const CFrameScheduler::Schedule& schedule, bool periodic,
bool deliveredToOwner) override;
void AbortFrameBuffer(const FrameToken& token) override;
void FailFrameBuffer(const FrameToken& token) override;
void CompleteFrameBuffer(
const FrameToken& token, bool succeeded) override;
void SetFrameTiming(const FrameToken& token, uint64_t captureTime,
uint64_t postProcessTime, uint64_t copyTime, uint64_t readyTime,
uint64_t holdTime, const CFrameScheduler::Schedule& schedule,
bool allowReadyReplacement, PreparedFrameBatch& batch) override;
uint32_t PublishFrameBatch(const FrameBatchToken& token) override;
void CommitFrameBatch(const FrameBatchToken& token) override;
void AbortFrameBatch(const FrameBatchToken& token) override;
void FailFrameBatch(const FrameBatchToken& token) override;
void WriteFrameTarget(const FrameBatchToken& token,
unsigned target, void * src, size_t offset, size_t len,
bool setWritePos) const override;
void WriteFrameTargetRows(const FrameBatchToken& token,
unsigned target, void * src, size_t offset, size_t rowBytes,
size_t pitch, unsigned rows) const override;
void FinalizeFrameTarget(const FrameBatchToken& token,
unsigned target) const override;
void SetFrameTargetTiming(const FrameBatchToken& token,
unsigned target, uint64_t captureTime, uint64_t postProcessTime,
uint64_t copyTime, uint64_t readyTime, uint64_t holdTime,
uint64_t completedAt) override;
void WriteFrameBuffer(const FrameToken& token, void * src,
size_t offset, size_t len, bool setWritePos) const override;
void WriteFrameBufferRows(const FrameToken& token, void * src,
size_t offset, size_t rowBytes, size_t pitch,
unsigned rows) const override;
void FinalizeFrameBuffer(const FrameToken& token) const override;
void TryRecordFrameTiming(const FrameBatchToken& token,
unsigned target, uint64_t duration) override;
void CompleteFrameTarget(const FrameBatchToken& token,
unsigned target, bool succeeded) override;
void ObserveFrame(uint64_t now) override;
void ForceFrame() override;
bool GetPublishTarget(uint64_t now, uint64_t& target,
CFrameScheduler::Schedule& schedule, bool& periodic,
bool& republish) override;
void FrameMissed(const CFrameScheduler::Schedule& schedule,
uint64_t now, bool periodic) override;
void FrameSuperseded() override;
HANDLE GetFrameScheduleEvent() const override;
void TryRecordFrameTiming(
const FrameToken& token, uint64_t duration) override;
HANDLE GetFrameScheduleEvent() const override { return m_wakeEvent; }
};

1030
idd/LGIdd/transport/CTransportManager.cpp
View File

File diff suppressed because it is too large Load Diff

94
idd/LGIdd/transport/CTransportManager.h
View File

@@ -25,7 +25,6 @@
#include "transport/ITransport.h"
#include <memory>
#include <vector>
class CTransportManager final
{
@@ -36,6 +35,19 @@ public:
using Recovery = ITransport::Recovery;
private:
mutable CSRWLock m_lock;
enum class Phase
{
IDLE,
OPEN,
INITIALIZE,
SETUP,
PROCESS,
ACCESS,
STOP,
};
enum class State
{
CLOSED,
@@ -47,41 +59,97 @@ private:
STOPPED,
};
enum class Call
{
IDLE,
LIFECYCLE,
PROCESS,
RECOVERY,
ACCESS,
};
struct RecoveryUpdate
{
uint64_t session = 0;
uint32_t serial = 0;
bool active = false;
Recovery state = Recovery::FAILED;
uint32_t error = 0;
};
struct Entry
{
BackendId id;
const char * name;
bool required;
bool primary;
CreateFn create;
std::unique_ptr<ITransport> transport;
Entry();
~Entry();
mutable CSRWLock lock;
HANDLE idleEvent = nullptr;
Call call = Call::IDLE;
DWORD callOwner = 0;
bool stopRequested = false;
BackendId id = 0;
const char * name = nullptr;
bool required = false;
bool primary = false;
CreateFn create = nullptr;
std::shared_ptr<ITransport> transport;
State state = State::CLOSED;
uint32_t epoch = 1;
uint64_t retryAt = 0;
bool controlAdded = false;
bool frameAdded = false;
bool exposed = false;
bool setupDone = false;
bool syncPending = false;
bool recoveryPending = false;
RecoveryUpdate recovery;
FrameMemoryLimits limits;
bool limitsValid = false;
DirectFrameBufferMemory directMemory;
bool directMemoryValid = false;
std::shared_ptr<ITransport> exposedTransport;
};
std::vector<std::unique_ptr<Entry>> m_entries;
std::unique_ptr<Entry> m_entries[FRAME_MAX_SINKS];
unsigned m_entryCount = 0;
CControlHub m_control;
CFrameHub m_frames;
Entry * m_primary = nullptr;
bool m_initialized = false;
bool m_setup = false;
bool m_exposed = false;
size_t m_alignment = 0;
Phase m_phase = Phase::IDLE;
DWORD m_phaseOwner = 0;
HANDLE m_phaseIdle = nullptr;
HANDLE m_stoppedEvent = nullptr;
bool m_started = false;
bool m_stopping = false;
bool m_stopped = false;
unsigned Entries(Entry * entries[FRAME_MAX_SINKS]) const;
Entry * Primary() const;
bool BeginPhase(Phase phase, bool wait, bool stopping = false);
void EndPhase();
bool BeginCall(Entry& entry, Call call, bool wait);
void EndCall(Entry& entry,
const std::shared_ptr<ITransport>& transport, bool drain = true);
void DrainRecovery(Entry& entry,
const std::shared_ptr<ITransport>& transport);
OpenResult OpenEntry(Entry& entry);
bool InitializeEntry(Entry& entry);
bool SetupEntry(Entry& entry);
void RetryEntry(Entry& entry, uint64_t now);
bool SetupEntry(Entry& entry, size_t alignment);
bool AddServices(Entry& entry);
void RetryEntry(Entry& entry, uint64_t now, bool initialized,
bool setup, size_t alignment);
void HandleProcessResult(Entry& entry, ProcessResult result);
void ScheduleRetry(Entry& entry);
void RemoveServices(Entry& entry);
ITransport& Primary();
void Expose(Entry& entry);
public:
CTransportManager() = default;
CTransportManager();
~CTransportManager();
CTransportManager(const CTransportManager&) = delete;

1
idd/LGIdd/transport/IFrameSink.h
View File

@@ -81,5 +81,6 @@ public:
uint64_t now, bool periodic) = 0;
virtual void FrameSuperseded() = 0;
virtual HANDLE GetFrameScheduleEvent() const = 0;
virtual void SetFrameScheduleEvent(HANDLE event) = 0;
virtual void TryRecordFrameTiming(uint64_t duration) = 0;
};

91
idd/LGIdd/transport/IFrameTransport.h
View File

@@ -28,60 +28,69 @@
#include <stddef.h>
#include <stdint.h>
struct FramePlanTarget
{
uint32_t sink = 0;
uint32_t backend = 0;
uint32_t epoch = 0;
CFrameScheduler::Schedule schedule = {};
CFrameScheduler::Schedule commitSchedule = {};
bool periodic = false;
bool primary = false;
};
struct FramePlan
{
FramePlanTarget targets[FRAME_MAX_SINKS] = {};
unsigned count = 0;
uint64_t nextWake = 0;
bool progressed = false;
};
class IFrameTransport
{
public:
virtual ~IFrameTransport() = default;
virtual size_t GetMaxFrameSize() const = 0;
virtual uint64_t NextContentSerial() = 0;
virtual void FrameProductReady(uint64_t contentSerial) = 0;
virtual bool NeedsFrame() const = 0;
virtual bool GetFramePlan(
uint64_t now, bool productReady, FramePlan& plan) = 0;
virtual bool GetImmediateFramePlan(
uint64_t now, FramePlan& plan) = 0;
virtual void MissFramePlan(const FramePlan& plan, uint64_t now) = 0;
virtual bool FrameBufferAvailable(
const CFrameScheduler::Schedule& schedule,
bool allowReadyReplacement = true) = 0;
virtual bool HasPublishedFrame() const = 0;
virtual void ProcessDeliveries() = 0;
virtual bool GetPendingDeliveryTarget(
uint64_t now, uint64_t& target) = 0;
virtual bool RetryPendingDelivery(uint64_t now, bool& retry) = 0;
virtual PreparedFrameBuffer PrepareFrameBuffer(unsigned pitch,
virtual bool PrepareFrameBatch(const FramePlan& plan,
uint64_t contentSerial, unsigned pitch, size_t frameSize,
const D12FrameFormat& srcFormat, const D12FrameFormat& dstFormat,
const RECT * dirtyRects, unsigned nbDirtyRects,
const CFrameScheduler::Schedule& schedule,
bool allowReadyReplacement = true) = 0;
virtual bool PublishFrameBuffer(const FrameToken& token,
const CFrameScheduler::Schedule& schedule,
bool& deliveredToOwner) = 0;
virtual bool RepublishFrameBuffer(
const CFrameScheduler::Schedule& schedule) = 0;
virtual bool TryFrameSubmitted(const FrameToken& token,
const CFrameScheduler::Schedule& schedule) = 0;
virtual void CommitFrameBuffer(const FrameToken& token,
const CFrameScheduler::Schedule& schedule, bool periodic,
bool deliveredToOwner) = 0;
virtual void AbortFrameBuffer(const FrameToken& token) = 0;
virtual void FailFrameBuffer(const FrameToken& token) = 0;
virtual void CompleteFrameBuffer(
const FrameToken& token, bool succeeded) = 0;
virtual void SetFrameTiming(const FrameToken& token, uint64_t captureTime,
uint64_t postProcessTime, uint64_t copyTime, uint64_t readyTime,
uint64_t holdTime, const CFrameScheduler::Schedule& schedule,
bool allowReadyReplacement, PreparedFrameBatch& batch) = 0;
virtual uint32_t PublishFrameBatch(const FrameBatchToken& token) = 0;
virtual void CommitFrameBatch(const FrameBatchToken& token) = 0;
virtual void AbortFrameBatch(const FrameBatchToken& token) = 0;
virtual void FailFrameBatch(const FrameBatchToken& token) = 0;
virtual void WriteFrameTarget(const FrameBatchToken& token,
unsigned target, void * src, size_t offset, size_t len,
bool setWritePos) const = 0;
virtual void WriteFrameTargetRows(const FrameBatchToken& token,
unsigned target, void * src, size_t offset, size_t rowBytes,
size_t pitch, unsigned rows) const = 0;
virtual void FinalizeFrameTarget(
const FrameBatchToken& token, unsigned target) const = 0;
virtual void SetFrameTargetTiming(const FrameBatchToken& token,
unsigned target, uint64_t captureTime, uint64_t postProcessTime,
uint64_t copyTime, uint64_t readyTime, uint64_t holdTime,
uint64_t completedAt) = 0;
virtual void WriteFrameBuffer(const FrameToken& token, void * src,
size_t offset, size_t len, bool setWritePos) const = 0;
virtual void WriteFrameBufferRows(const FrameToken& token, void * src,
size_t offset, size_t rowBytes, size_t pitch,
unsigned rows) const = 0;
virtual void FinalizeFrameBuffer(const FrameToken& token) const = 0;
virtual void TryRecordFrameTiming(const FrameBatchToken& token,
unsigned target, uint64_t duration) = 0;
virtual void CompleteFrameTarget(const FrameBatchToken& token,
unsigned target, bool succeeded) = 0;
virtual void ObserveFrame(uint64_t now) = 0;
virtual void ForceFrame() = 0;
virtual bool GetPublishTarget(uint64_t now, uint64_t& target,
CFrameScheduler::Schedule& schedule, bool& periodic,
bool& republish) = 0;
virtual void FrameMissed(const CFrameScheduler::Schedule& schedule,
uint64_t now, bool periodic) = 0;
virtual void FrameSuperseded() = 0;
virtual HANDLE GetFrameScheduleEvent() const = 0;
virtual void TryRecordFrameTiming(
const FrameToken& token, uint64_t duration) = 0;
};

41
idd/LGIdd/transport/PreparedFrameBuffer.h
View File

@@ -20,8 +20,17 @@
#pragma once
#include <stddef.h>
#include <stdint.h>
enum : unsigned
{
FRAME_MAX_SINKS = 8,
FRAME_BATCHES = 3,
FRAME_SINK_BUFFERS = 3,
FRAME_BUFFER_RESOURCES = FRAME_MAX_SINKS * FRAME_SINK_BUFFERS,
};
struct FrameToken
{
uint32_t sink = 0;
@@ -33,16 +42,32 @@ struct FrameToken
struct PreparedFrameBuffer
{
FrameToken token;
unsigned resourceSlot;
uint8_t * mem;
uint64_t heapOffset;
bool fullCopy;
unsigned resourceSlot = 0;
uint8_t * mem = nullptr;
uint64_t heapOffset = 0;
size_t capacity = 0;
bool direct = false;
bool fullCopy = false;
};
struct FrameBatchToken
{
uint32_t slot = 0;
uint64_t serial = 0;
};
struct PreparedFrameBatch
{
FrameBatchToken token;
PreparedFrameBuffer targets[FRAME_MAX_SINKS] = {};
unsigned count = 0;
};
struct SinkTarget
{
unsigned slot;
uint8_t * mem;
uint64_t heapOffset;
bool fullCopy;
unsigned slot = 0;
uint8_t * mem = nullptr;
uint64_t heapOffset = 0;
size_t capacity = 0;
bool fullCopy = false;
};

3
idd/LGIdd/transport/lgmp/CLGMPFrameTransport.cpp
View File

@@ -917,7 +917,10 @@ SinkTarget CLGMPFrameTransport::PrepareFrameBuffer(
result.mem = fb->data;
result.heapOffset = reinterpret_cast<uintptr_t>(fb->data) -
reinterpret_cast<uintptr_t>(m_ivshmem.GetMem());
result.capacity = m_maxFrameSize;
result.fullCopy = fullCopy;
if (fullCopy)
fi->damageRectsCount = 0;
return result;
}

4
idd/LGIdd/transport/lgmp/CLGMPFrameTransport.h
View File

@@ -214,5 +214,9 @@ public:
{
return m_frameScheduler.GetWakeEvent();
}
void SetFrameScheduleEvent(HANDLE event) override
{
m_frameScheduler.SetSharedWakeEvent(event);
}
void TryRecordFrameTiming(uint64_t duration) override;
};