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

[client/host/idd/obs] scheduler: validate phase feedback

Browse Source 
Bump KVMFR to version 28 and attach generation, epoch, and deadline
identities to cadence deliveries and their timing records.

Accept phase corrections only for the exact completed publication. Keep
VM and client clocks independent by exchanging relative phase errors.

Make submission, completion, and work-estimate accounting best effort
so scheduler state cannot delay GPU submission or frame publication.
This commit is contained in:
Geoffrey McRae
2026-08-06 16:05:05 +10:00
parent 983cf588e3
commit 515f4ba06f
16 changed files with 688 additions and 235 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
client/include/interface/transport.h
View File

@@ -96,6 +96,10 @@ typedef uint32_t LG_TransportFrameFlags;
typedef struct LG_TransportFrameTiming
{
bool valid; /* producer fields below are available and coherent */
bool phaseValid;
uint32_t scheduleGeneration;
uint32_t scheduleEpoch;
uint32_t scheduleDeadlineSerial;
uint64_t captureTime;
uint64_t postProcessTime;
uint64_t copyTime;
@@ -134,8 +138,8 @@ typedef struct LG_TransportFrame
{
uint64_t serial;
uint64_t timestamp;
uint32_t scheduleGeneration;
uint32_t scheduleEpoch;
uint32_t scheduleDeadlineSerial;
LG_TransportFrameFlags flags;
bool scheduleOwner;
// Backend-owned immutable metadata, valid until releaseFrame.
@@ -216,6 +220,7 @@ typedef struct LG_TransportControl
int64_t phaseError;
uint32_t feedbackFrameSerial;
uint32_t feedbackScheduleEpoch;
uint32_t feedbackDeadlineSerial;
uint32_t lease;
}
frameSchedule;

82
client/src/frame_scheduler.c
View File

@@ -52,6 +52,7 @@ static struct
int64_t phaseError;
uint32_t feedbackFrameSerial;
uint32_t feedbackScheduleEpoch;
uint32_t feedbackDeadlineSerial;
unsigned feedbackSamples;
bool feedbackDirty;
@@ -92,23 +93,26 @@ static bool sendSchedule(LG_TransportFrameScheduleFlags flags,
int64_t phaseError;
uint32_t feedbackFrameSerial;
uint32_t feedbackScheduleEpoch;
uint32_t feedbackDeadlineSerial;
LG_LOCK(l_frameScheduler.lock);
phaseError = l_frameScheduler.phaseError;
feedbackFrameSerial = l_frameScheduler.feedbackFrameSerial;
feedbackScheduleEpoch = l_frameScheduler.feedbackScheduleEpoch;
phaseError = l_frameScheduler.phaseError;
feedbackFrameSerial = l_frameScheduler.feedbackFrameSerial;
feedbackScheduleEpoch = l_frameScheduler.feedbackScheduleEpoch;
feedbackDeadlineSerial = l_frameScheduler.feedbackDeadlineSerial;
LG_UNLOCK(l_frameScheduler.lock);
const LG_TransportControl control = {
.type = LG_TRANSPORT_CONTROL_FRAME_SCHEDULE,
.frameSchedule = {
.generation = l_frameScheduler.generation,
.flags = flags,
.period = period,
.targetSlack = FRAME_SCHEDULER_TARGET_SLACK_NS,
.phaseError = phaseError,
.feedbackFrameSerial = feedbackFrameSerial,
.feedbackScheduleEpoch = feedbackScheduleEpoch,
.lease = FRAME_SCHEDULER_LEASE_MS,
.generation = l_frameScheduler.generation,
.flags = flags,
.period = period,
.targetSlack = FRAME_SCHEDULER_TARGET_SLACK_NS,
.phaseError = phaseError,
.feedbackFrameSerial = feedbackFrameSerial,
.feedbackScheduleEpoch = feedbackScheduleEpoch,
.feedbackDeadlineSerial = feedbackDeadlineSerial,
.lease = FRAME_SCHEDULER_LEASE_MS,
},
};
@@ -127,7 +131,8 @@ static bool sendSchedule(LG_TransportFrameScheduleFlags flags,
l_frameScheduler.immediatePending = false;
LG_LOCK(l_frameScheduler.lock);
if (l_frameScheduler.feedbackFrameSerial == feedbackFrameSerial &&
l_frameScheduler.feedbackScheduleEpoch == feedbackScheduleEpoch)
l_frameScheduler.feedbackScheduleEpoch == feedbackScheduleEpoch &&
l_frameScheduler.feedbackDeadlineSerial == feedbackDeadlineSerial)
l_frameScheduler.feedbackDirty = false;
LG_UNLOCK(l_frameScheduler.lock);
return true;
@@ -156,11 +161,12 @@ void frameScheduler_start(LG_TransportFeatureFlags features)
++l_frameScheduler.generation;
LG_LOCK(l_frameScheduler.lock);
l_frameScheduler.phaseError = 0;
l_frameScheduler.feedbackFrameSerial = 0;
l_frameScheduler.feedbackScheduleEpoch = 0;
l_frameScheduler.feedbackSamples = 0;
l_frameScheduler.feedbackDirty = false;
l_frameScheduler.phaseError = 0;
l_frameScheduler.feedbackFrameSerial = 0;
l_frameScheduler.feedbackScheduleEpoch = 0;
l_frameScheduler.feedbackDeadlineSerial = 0;
l_frameScheduler.feedbackSamples = 0;
l_frameScheduler.feedbackDirty = false;
LG_UNLOCK(l_frameScheduler.lock);
}
@@ -194,11 +200,12 @@ void frameScheduler_update(void)
l_frameScheduler.period = 0;
l_frameScheduler.immediatePending = true;
LG_LOCK(l_frameScheduler.lock);
l_frameScheduler.phaseError = 0;
l_frameScheduler.feedbackFrameSerial = 0;
l_frameScheduler.feedbackScheduleEpoch = 0;
l_frameScheduler.feedbackSamples = 0;
l_frameScheduler.feedbackDirty = false;
l_frameScheduler.phaseError = 0;
l_frameScheduler.feedbackFrameSerial = 0;
l_frameScheduler.feedbackScheduleEpoch = 0;
l_frameScheduler.feedbackDeadlineSerial = 0;
l_frameScheduler.feedbackSamples = 0;
l_frameScheduler.feedbackDirty = false;
LG_UNLOCK(l_frameScheduler.lock);
}
return;
@@ -219,11 +226,12 @@ void frameScheduler_update(void)
++l_frameScheduler.generation;
l_frameScheduler.immediatePending = true;
LG_LOCK(l_frameScheduler.lock);
l_frameScheduler.phaseError = 0;
l_frameScheduler.feedbackFrameSerial = 0;
l_frameScheduler.feedbackScheduleEpoch = 0;
l_frameScheduler.feedbackSamples = 0;
l_frameScheduler.feedbackDirty = false;
l_frameScheduler.phaseError = 0;
l_frameScheduler.feedbackFrameSerial = 0;
l_frameScheduler.feedbackScheduleEpoch = 0;
l_frameScheduler.feedbackDeadlineSerial = 0;
l_frameScheduler.feedbackSamples = 0;
l_frameScheduler.feedbackDirty = false;
LG_UNLOCK(l_frameScheduler.lock);
}
else
@@ -257,9 +265,10 @@ void frameScheduler_update(void)
}
void frameScheduler_feedback(uint64_t frameSerial, uint32_t generation,
uint32_t scheduleEpoch, uint64_t measuredPhase)
uint32_t scheduleEpoch, uint32_t deadlineSerial,
uint64_t measuredPhase)
{
if (!generation || !scheduleEpoch)
if (!generation || !scheduleEpoch || !deadlineSerial)
return;
LG_LOCK(l_frameScheduler.lock);
@@ -270,6 +279,14 @@ void frameScheduler_feedback(uint64_t frameSerial, uint32_t generation,
return;
}
if (l_frameScheduler.feedbackFrameSerial == (uint32_t)frameSerial &&
l_frameScheduler.feedbackScheduleEpoch == scheduleEpoch &&
l_frameScheduler.feedbackDeadlineSerial == deadlineSerial)
{
LG_UNLOCK(l_frameScheduler.lock);
return;
}
const int64_t period = (int64_t)l_frameScheduler.period;
if (!period)
{
@@ -301,8 +318,9 @@ void frameScheduler_feedback(uint64_t frameSerial, uint32_t generation,
if (l_frameScheduler.feedbackSamples < 32)
++l_frameScheduler.feedbackSamples;
l_frameScheduler.feedbackFrameSerial = (uint32_t)frameSerial;
l_frameScheduler.feedbackScheduleEpoch = scheduleEpoch;
l_frameScheduler.feedbackDirty = true;
l_frameScheduler.feedbackFrameSerial = (uint32_t)frameSerial;
l_frameScheduler.feedbackScheduleEpoch = scheduleEpoch;
l_frameScheduler.feedbackDeadlineSerial = deadlineSerial;
l_frameScheduler.feedbackDirty = true;
LG_UNLOCK(l_frameScheduler.lock);
}

3
client/src/frame_scheduler.h
View File

@@ -31,6 +31,7 @@ void frameScheduler_start(LG_TransportFeatureFlags features);
void frameScheduler_stop(void);
void frameScheduler_update(void);
void frameScheduler_feedback(uint64_t frameSerial, uint32_t generation,
uint32_t scheduleEpoch, uint64_t measuredPhase);
uint32_t scheduleEpoch, uint32_t deadlineSerial,
uint64_t measuredPhase);
#endif

46
client/src/main.c
View File

@@ -217,9 +217,10 @@ struct FrameTimingRecord
uint64_t frameSerial;
uint32_t scheduleGeneration;
uint32_t scheduleEpoch;
uint32_t scheduleDeadlineSerial;
unsigned readyMask;
bool producerValid;
bool scheduleOwner;
bool phaseValid;
uint64_t captureTime;
uint64_t postProcessTime;
@@ -330,9 +331,8 @@ static void frameTimingCancel(LG_RendererFrameToken token)
}
static void frameTimingQueue(LG_RendererFrameToken token, uint64_t frameSerial,
uint32_t scheduleGeneration, uint32_t scheduleEpoch, bool scheduleOwner,
uint64_t importTime, uint64_t importWaitTime, uint64_t dispatchStart,
uint64_t queueStart)
const LG_TransportFrameTiming * timing, uint64_t importTime,
uint64_t importWaitTime, uint64_t dispatchStart, uint64_t queueStart)
{
INTERLOCKED_SECTION(l_frameTiming.lock, {
struct FrameTimingRecord * record = frameTimingRecord(token);
@@ -341,14 +341,16 @@ static void frameTimingQueue(LG_RendererFrameToken token, uint64_t frameSerial,
const uint64_t elapsed = queueStart > dispatchStart ?
queueStart - dispatchStart : 0;
const uint64_t accounted = importTime + importWaitTime;
record->importTime = importTime;
record->importWaitTime = importWaitTime;
record->dispatchTime = elapsed > accounted ? elapsed - accounted : 0;
record->queueStart = queueStart;
record->frameSerial = frameSerial;
record->scheduleGeneration = scheduleGeneration;
record->scheduleEpoch = scheduleEpoch;
record->scheduleOwner = scheduleOwner;
record->importTime = importTime;
record->importWaitTime = importWaitTime;
record->dispatchTime = elapsed > accounted ?
elapsed - accounted : 0;
record->queueStart = queueStart;
record->frameSerial = frameSerial;
record->scheduleGeneration = timing->scheduleGeneration;
record->scheduleEpoch = timing->scheduleEpoch;
record->scheduleDeadlineSerial = timing->scheduleDeadlineSerial;
record->phaseValid = timing->phaseValid;
if (record->timestamp < queueStart)
record->timestamp = queueStart;
}
@@ -398,7 +400,8 @@ static void frameTimingFinishRender(const LG_RendererFrameTiming * timing,
uint64_t feedbackQueueStart = 0;
uint32_t feedbackGeneration = 0;
uint32_t feedbackEpoch = 0;
bool feedbackOwner = false;
uint32_t feedbackDeadline = 0;
bool feedbackValid = false;
LG_LOCK(l_frameTiming.lock);
if (l_frameTiming.retireToken <= timing->frameToken)
@@ -421,7 +424,8 @@ static void frameTimingFinishRender(const LG_RendererFrameTiming * timing,
feedbackFrameSerial = record->frameSerial;
feedbackGeneration = record->scheduleGeneration;
feedbackEpoch = record->scheduleEpoch;
feedbackOwner = record->scheduleOwner;
feedbackDeadline = record->scheduleDeadlineSerial;
feedbackValid = record->phaseValid;
feedbackQueueStart = record->queueStart;
if (unlikely(
@@ -445,13 +449,13 @@ static void frameTimingFinishRender(const LG_RendererFrameTiming * timing,
}
LG_UNLOCK(l_frameTiming.lock);
if (g_state.jitRender && feedbackOwner && feedbackFrameSerial &&
feedbackGeneration && feedbackEpoch && feedbackQueueStart &&
prepareStart >= feedbackQueueStart)
if (g_state.jitRender && feedbackValid && feedbackFrameSerial &&
feedbackGeneration && feedbackEpoch && feedbackDeadline &&
feedbackQueueStart && prepareStart >= feedbackQueueStart)
{
frameScheduler_feedback(
feedbackFrameSerial, feedbackGeneration, feedbackEpoch,
prepareStart - feedbackQueueStart);
feedbackDeadline, prepareStart - feedbackQueueStart);
}
}
@@ -1143,9 +1147,9 @@ int main_frameThread(void * unused)
atomic_store_explicit(&l_testFrameSerial, frame.serial,
memory_order_release);
#endif
frameTimingQueue(frameToken, frame.serial, frame.scheduleGeneration,
frame.scheduleEpoch, frame.scheduleOwner, g_state.frameImportTime,
g_state.frameImportWaitTime, dispatchStart, queueStart);
frameTimingQueue(frameToken, frame.serial, &timing,
g_state.frameImportTime, g_state.frameImportWaitTime,
dispatchStart, queueStart);
if (g_state.jitRender)
{

63
client/transports/LGMP/lgmp.c
View File

@@ -721,6 +721,18 @@ static bool lgmp_frameSerialNewer(uint32_t lhs, uint32_t rhs)
(uint32_t)(lhs - rhs) < UINT32_C(0x80000000);
}
static bool lgmp_frameMessageHasMatchingDeadline(
const struct LGMPFrameMessage * message)
{
if (!message->owner)
return false;
const uint32_t epoch = (uint32_t)(message->message.udata >> 32);
const uint32_t deadlineSerial = (uint32_t)message->message.udata;
return deadlineSerial && epoch == message->frame->scheduleEpoch &&
deadlineSerial == message->frame->scheduleDeadlineSerial;
}
static void lgmp_selectNewestFrameMessage(
struct LGMPFrameMessage * candidate,
struct LGMPFrameMessage ** selected)
@@ -732,7 +744,9 @@ static void lgmp_selectNewestFrameMessage(
lgmp_frameSerialNewer(candidate->frame->frameSerial,
(*selected)->frame->frameSerial) ||
(candidate->frame->frameSerial == (*selected)->frame->frameSerial &&
candidate->owner && !(*selected)->owner))
((candidate->owner && !(*selected)->owner) ||
(lgmp_frameMessageHasMatchingDeadline(candidate) &&
!lgmp_frameMessageHasMatchingDeadline(*selected)))))
*selected = candidate;
}
@@ -917,9 +931,9 @@ static LG_TransportStatus lgmp_nextFrameLocked(LG_Transport * this,
if (selected->owner)
{
const uint64_t scheduleToken = selected->message.udata;
result->scheduleGeneration = (uint32_t)(scheduleToken >> 32);
result->scheduleEpoch = (uint32_t)scheduleToken;
result->scheduleOwner = true;
result->scheduleEpoch = (uint32_t)(scheduleToken >> 32);
result->scheduleDeadlineSerial = (uint32_t)scheduleToken;
result->scheduleOwner = true;
}
if (frame->flags & FRAME_FLAG_BLOCK_SCREENSAVER)
result->flags |= LG_TRANSPORT_FRAME_BLOCK_SCREENSAVER;
@@ -1057,11 +1071,20 @@ static void lgmp_getFrameTiming(LG_Transport * this,
return;
}
timing->valid = true;
timing->captureTime = lease->frame->captureTime;
timing->postProcessTime = lease->frame->postProcessTime;
timing->copyTime = lease->frame->copyTime;
timing->readyTime = lease->frame->readyTime;
timing->valid = true;
timing->scheduleGeneration = lease->frame->scheduleGeneration;
timing->scheduleEpoch = lease->frame->scheduleEpoch;
timing->scheduleDeadlineSerial = lease->frame->scheduleDeadlineSerial;
timing->phaseValid = frame->scheduleOwner &&
timing->scheduleGeneration && timing->scheduleEpoch &&
timing->scheduleDeadlineSerial &&
timing->scheduleEpoch == frame->scheduleEpoch &&
timing->scheduleDeadlineSerial == frame->scheduleDeadlineSerial &&
(lease->frame->timingFlags & KVMFR_FRAME_TIMING_PHASE_VALID);
timing->captureTime = lease->frame->captureTime;
timing->postProcessTime = lease->frame->postProcessTime;
timing->copyTime = lease->frame->copyTime;
timing->readyTime = lease->frame->readyTime;
LG_UNLOCK(this->frameLock);
}
@@ -1244,17 +1267,19 @@ static LG_TransportStatus lgmp_sendControl(LG_Transport * this,
case LG_TRANSPORT_CONTROL_FRAME_SCHEDULE:
{
const KVMFRFrameSchedule message = {
.msg.type = KVMFR_MESSAGE_FRAME_SCHEDULE,
.clientID = this->clientID,
.generation = control->frameSchedule.generation,
.flags = control->frameSchedule.flags,
.period = control->frameSchedule.period,
.targetSlack = control->frameSchedule.targetSlack,
.phaseError = control->frameSchedule.phaseError,
.feedbackFrameSerial = control->frameSchedule.feedbackFrameSerial,
.feedbackScheduleEpoch =
.msg.type = KVMFR_MESSAGE_FRAME_SCHEDULE,
.clientID = this->clientID,
.generation = control->frameSchedule.generation,
.flags = control->frameSchedule.flags,
.period = control->frameSchedule.period,
.targetSlack = control->frameSchedule.targetSlack,
.phaseError = control->frameSchedule.phaseError,
.feedbackFrameSerial = control->frameSchedule.feedbackFrameSerial,
.feedbackScheduleEpoch =
control->frameSchedule.feedbackScheduleEpoch,
.lease = control->frameSchedule.lease,
.feedbackDeadlineSerial =
control->frameSchedule.feedbackDeadlineSerial,
.lease = control->frameSchedule.lease,
};
memcpy(buffer, &message, sizeof(message));
size = sizeof(message);