Method EnqueueWork

PresentData/GpuTrace.cpp:260–314

}

void GpuTrace::EnqueueWork(Context* context, uint32_t sequenceId, uint64_t timestamp, bool isWaitPacket)
{
    auto packetTrace = context->mPacketTrace;
    auto node = context->mNode;

    // A very rare (never observed) race exists where packetTrace can still be
    // nullptr here.  The context must have been created and this packet must
    // have been submitted to the queue before the capture started.
    //
    // In this case, we have to ignore the DMA packet otherwise the node and
    // process tracking will become out of sync.
    if (packetTrace == nullptr) {
        return;
    }

    // If the queue is too small, enlarge it by 16 entries at a time.  Typically, this will only be
    // needed for the first packet observed on this node, which will result in sizing the queue from
    // 0 to 16.  However, there are other cases where the queue entries can grow beyond that.  e.g.,
    // this seems to always happen when an application closes.
    uint32_t queueSize = (uint32_t) node->mQueue.size();
    if (node->mQueueCount == queueSize) {
        Node::EnqueuedPacket empty{};
        node->mQueue.insert(node->mQueue.begin() + node->mQueueIndex, 16, empty);
        queueSize += 16;
        node->mQueueIndex = (node->mQueueIndex + 16) % queueSize;
    }

    // Enqueue the packet.
    //
    // Wait packets aren't counted as GPU work, but we still need to enqueue
    // them so they block future work.  We encode wait packets by setting their
    // packetTrace to null.  This saves some memory as we don't need the
    // packetTrace pointer for wait packets.
    if (isWaitPacket) {
        packetTrace = nullptr;
    }

    auto queueIndex = (node->mQueueIndex + node->mQueueCount) % queueSize;
    auto entry = &node->mQueue[queueIndex];
    entry->mPacketTrace = packetTrace;
    entry->mSequenceId = sequenceId;
    entry->mCompleted = false;
    node->mQueueCount += 1;

    // If the queue was empty, the packet starts running right away, otherwise
    // it is just enqueued and will start running after all previous packets
    // complete.
    if (packetTrace != nullptr && node->mQueueCount == 1) {
        StartPacket(packetTrace, timestamp);
    }

    if (IsVerboseTraceEnabled()) {
        PrintRunningContexts();
    }
}

bool GpuTrace::CompleteWork(Context* context, uint32_t sequenceId, uint64_t timestamp)
{