> ## Documentation Index
> Fetch the complete documentation index at: https://devdocs.xbox.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Prise en charge de la suspension et de la reprise dans Direct3D

> Prise en charge de la suspension et de la reprise dans Direct3D

Cette rubrique décrit le processus de suspension et de reprise du rendu graphique Direct3D d'un titre Game OS.

* [Événements de suspension et de reprise](#ID4EN)
* [Incidences sur la planification des images et les statistiques](#ID4FrameSchedulingResume)
* [Modèle d'appel](#ID4EEC)
* [Tests](#ID4EBF)

<a id="ID4EN" />

## Événements de suspension et de reprise

Sur XBOX One, les applications Game OS peuvent être suspendues et reprises par la gestion de la durée de vie des processus (PLM). À l'état suspendu, la mémoire de l'application reste intacte, mais l'application ne dispose d'aucune ressource processeur ou GPU. L'implémentation de la suspension et de la reprise par les applications Game OS fait partie des exigences XBOX (XR) pour XBOX One.

Si une application reçoit l'événement **Suspending**, elle doit appeler **SuspendX**. Sinon, l'application sera arrêtée. Les appels **SuspendX** et **ResumeX** doivent tous deux s'exécuter sur le thread de rendu du titre afin de garantir que l'état du GPU est correctement enregistré par l'appel **SuspendX**.

Lorsque le titre est suspendu, il ne peut rien afficher tant que le GPU n'a pas repris. L'appel de toute API Direct3D entre les appels Direct3D **SuspendX** et **ResumeX**, comme l'appel des méthodes **ID3D12GraphicsCommandList::DrawInstanced** ou **ID3D12CommandQueue::ExecuteCommandLists**, lève une exception.

Voici les méthodes de suspension et de reprise de Direct3D sur XBOX One.

* [ID3D12CommandQueue::SuspendX](/fr-CA/reference/graphics/d3d12_x/interfaces/id3d12commandqueue/methods/id3d12commandqueue_suspendx)
* [ID3D12CommandQueue::ResumeX](/fr-CA/reference/graphics/d3d12_x/interfaces/id3d12commandqueue/methods/id3d12commandqueue_resumex)

Ces méthodes doivent être appelées sur la file d'attente de commandes graphiques, car elles ne sont pas prises en charge par les files d'attente de calcul et de copie.

<a id="ID4FrameSchedulingResume" />

## Incidences sur la planification des images et les statistiques

La suspension de l'application introduit une perturbation non déterministe dans la planification des images qu'elle a établie. Étant donné le caractère imprévisible du moment où un événement de suspension peut se produire, il n'est pas possible pour le système de restaurer de façon sécuritaire la planification établie et son état temporel après l'événement de reprise subséquent. Afin d'offrir un comportement robuste et prévisible, la planification des images de l'application est effacée par le système pendant le traitement de l'appel **SuspendX**. La file d'attente de présentation est vidée vers l'écran, et toutes les images commencées par **WaitFrameEventX** mais pas encore envoyées à l'écran au moyen de **PresentX** sont abandonnées.

Par conséquent, après le retour de l'appel **ResumeX**, l'application doit rétablir la planification des images souhaitée au moyen d'appels à **ID3D12Device::SetFrameIntervalX** et à **ID3D12Device::ScheduleFrameEventX** avant de se mettre en attente de sa prochaine origine d'image. L'application doit supposer que le pipeline d'images est vide après sa reprise.

<Note>
  Il peut être courant qu'une application reçoive un événement de suspension pendant qu'elle attend qu'une origine d'image (ou un autre événement d'image) soit signalée lors d'un appel à **ID3D12Device::WaitFrameEventX**. Si le thread de l'application responsable de l'appel de **SuspendX** sur la file d'attente de commandes graphiques est différent de celui utilisé pour attendre les événements d'image, l'appel **ID3D12Device::WaitFrameEventX** (bien qu'il ait été lancé avant l'appel **SuspendX**) peut échouer avec D3DERR\_DEVICEREMOVED.
</Note>

Les statistiques d'images ne sont pas conservées d'un côté à l'autre des limites de suspension/reprise. Tous les jetons d'image émis avant une suspension seront considérés comme non valides après la reprise, et les appels **ID3D12Device::GetFrameStatisticsX** qui y font référence pour obtenir les informations statistiques associées échoueront.

<a id="ID4EEC" />

## Modèle d'appel

Les applications Game OS reçoivent des notifications au moyen de rappels inscrits. Il n'y a qu'un événement de suspension et un événement de reprise, et il n'y a plus de phase d'activation explicite. Une approche d'implémentation simple consiste à gérer la suspension et la reprise en publiant un message WM\_USER.

```cpp theme={null}
#include <appnotify.h>

PAPPSTATE_REGISTRATION hPLM = {};
HANDLE plmSuspendComplete = nullptr;
HANDLE plmSignalResume = nullptr;

// Create a window.

plmSuspendComplete = CreateEventEx(nullptr, nullptr, 0, EVENT_MODIFY_STATE | SYNCHRONIZE);
plmSignalResume = CreateEventEx(nullptr, nullptr, 0, EVENT_MODIFY_STATE | SYNCHRONIZE);
if (!plmSuspendComplete || !plmSignalResume)
    return 1;

if (RegisterAppStateChangeNotification([](BOOLEAN quiesced, PVOID context)
{
    if (quiesced)
    {
        ResetEvent(plmSuspendComplete);
        ResetEvent(plmSignalResume);

        // To ensure we use the main UI thread to process the notification, we self-post a message.
        PostMessage(reinterpret_cast<HWND>(context), WM_USER, 0, 0);

        // To defer suspension, we must wait to exit this callback.
        (void)WaitForSingleObject(plmSuspendComplete, INFINITE);
    }
    else
    {
        SetEvent(plmSignalResume);
    }
}, hwnd, &hPLM))
    return 1;

// Message loop

UnregisterAppStateChangeNotification(hPLM);

CloseHandle(plmSuspendComplete);
CloseHandle(plmSignalResume);
```

Si la pompe de messages s'exécute sur un thread de rendu disposant d'un accès exclusif à la file d'attente de commandes graphiques, cela permet d'appeler directement les méthodes Direct3D **SuspendX** et **ResumeX** à partir du gestionnaire de messages WM\_USER. Tous les threads distincts qui soumettent du travail à des files d'attente de commandes de calcul asynchrone ou de copie doivent recevoir l'instruction de cesser les opérations sur les files d'attente avant l'appel à **SuspendX**.

```cpp theme={null}
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
...
    switch (message)
    {
    case WM_USER:
        // Notify any threads using other command queues to halt operations and wait for acknowledgement.

        // Call SuspendX(0) on the graphics command queue, and cease all GPU submissions. This API is asynchronous so
        // that the game can continue doing work below.
        pGraphicsQueue->SuspendX(0);

        // Complete deferral.
        SetEvent(plmSuspendComplete);

        (void)WaitForSingleObject(plmSignalResume, INFINITE);

        // Before picking up rendering again, call ResumeX on the graphics command queue.
        pGraphicsQueue->ResumeX();

        // Notify any threads using other command queues that it's safe to resume operations.

        // Register again for frame events via SetFrameIntervalX and ScheduleFrameEventX.
        break;
    }
```

Si la pompe de messages s'exécute sur un thread différent d'un ou de plusieurs des threads ayant accès à la file d'attente de commandes graphiques, elle doit demander au thread de rendu d'effectuer l'appel **SuspendX** et de cesser d'utiliser la file d'attente (et gérer de la même façon **ResumeX** et les opérations associées).

Lorsque l'appel **SuspendX** est effectué, le runtime Direct3D enregistre l'état des registres de contexte, de la RAM CE, de l'ESRAM, du magasin de données global (GDS), des mémoires tampons d'index, de certains registres du GPU (les registres du GPU ne sont pas tous lisibles) et de la mémoire interne du CP. Cet état est restauré lors de l'appel **ResumeX**.

Le système PLM définit quatre états dans lesquels une application peut se trouver : **Non restreint**, **Restreint**, **Suspendu** et **Arrêté**.

Pour plus d'informations, consultez [Gestion de la durée de vie des processus (Developer Education Materials, All NDA Whitepapers)](https://aka.ms/xgddl).

<a id="ID4EBF" />

## Tests

Pour permettre des tests réalistes de la suspension et de la reprise, la commande à distance [Gestion des applications (xbapp.exe)](/fr-CA/tools/tools-console/commandlinetools/xbapp) offre des options. Consultez la section sur **xbapp suspend** dans cette rubrique, et notez l'exemple de fichier de commandes.

<a id="ID4EOF" />


## Related topics

- [Répertoire des rubriques NDA : liens actifs vers Microsoft Learn](/fr-CA/nda/nda-topic-directory.md)
- [Guide de programmation Direct3D 12](/fr/build/gdk-and-engines/guides/directx-12-programming-guide.md)
- [Notes de version du SDK C++ PlayFab Multiplayer](/fr-CA/services/playfab/multiplayer/lobby/lobby-matchmaking-sdks/lobby-and-matchmaking-release-notes.md)
- [Aperçu de XBOX Series X|S](/fr-CA/paths/series-xs/overview.md)
- [Vue d'ensemble de XBOX Series X|S](/fr/paths/series-xs/overview.md)