Funktionen zur Aufzeichnung der Ladezeit hinzufügen

Es ist aus zwei Gründen wichtig, zu erfassen, wann in Ihrem Spiel Ladeereignisse ausgeführt werden:

1. Damit deine Frame Time-Daten während des Ladevorgangs nicht verschmutzt werden.
2. Analysieren der Ladezeiten, um zu sehen, wann und wo sie länger als akzeptabel sind

Einem Ladeereignis können zugehörige Metadaten zugeordnet sein:

typedef struct TuningFork_LoadingTimeMetadata {
    enum LoadingState {
        UNKNOWN_STATE = 0,
        // The first time the game is run
        FIRST_RUN = 1,
        // App is not backgrounded
        COLD_START = 2,
        // App is backgrounded
        WARM_START = 3,
        // App is backgrounded, least work needed
        HOT_START = 4,
        // Asset loading between levels
        INTER_LEVEL = 5
    } state;
    enum LoadingSource {
        UNKNOWN_SOURCE = 0,
        // Uncompressing data.
        MEMORY = 1,
        // Reading assets from APK bundle.
        APK = 2,
        // Reading assets from device storage.
        DEVICE_STORAGE = 3,
        // Reading assets from external storage, e.g. SD card.
        EXTERNAL_STORAGE = 4,
        // Loading assets from the network.
        NETWORK = 5,
        // Shader compilation.
        SHADER_COMPILATION = 6,
        // Time spent between process starting and onCreate.
        PRE_ACTIVITY = 7,
        // Total time spent between process starting and first render frame.
        FIRST_TOUCH_TO_FIRST_FRAME = 8
    } source;
    int32_t compression_level;  // 0 = no compression, 100 = max compression
    enum NetworkConnectivity {
        UNKNOWN = 0,
        WIFI = 1,
        CELLULAR_NETWORK = 2
    } network_connectivity;
    uint64_t network_transfer_speed_bps;  // bandwidth in bits per second
    uint64_t network_latency_ns;          // latency in nanoseconds
} TuningFork_LoadingTimeMetadata;

Alle Felder, die für Ihre Anforderungen nicht relevant sind, können null sein.

Einem Ladeereignis kann auch eine Annotation zugeordnet sein. Dies wird auf die gleiche Weise wie Frame Time-Annotationen definiert, indem ein oder mehrere Felder in der Annotation-Nachricht in der Datei dev_tuningfork.proto verwendet werden.

TuningFork_ErrorCode TuningFork_startRecordingLoadingTime( const TuningFork_LoadingTimeMetadata* eventMetadata, uint32_t eventMetadataSize, const TuningFork_CProtobufSerialization* annotation, TuningFork_LoadingEventHandle* handle);

Diese Funktion beginnt mit der Aufzeichnung eines Ladezeitereignisses, das mit den angegebenen Metadaten und der Annotation verknüpft ist, und fügt eine handle ein, die in der Funktion TuningFork_stopRecordingLoadingTime() verwendet werden soll.

TuningFork_ErrorCode TuningFork_stopRecordingLoadingTime( TuningFork_LoadingEventHandle handle);

Diese Funktion beendet die Aufzeichnung eines Ereignisses, das zuvor von TuningFork_startRecordingLoadingTime() gestartet wurde. Das Ereignis wird bei der nächsten Leerung der Sitzung hochgeladen.

TuningFork_ErrorCode TuningFork_recordLoadingTime( uint64_t time_ns, const TuningFork_LoadingTimeMetadata* eventMetadata, uint32_t eventMetadataSize, const TuningFork_CProtobufSerialization* annotation);

Es wird dringend empfohlen, die oben beschriebenen Start- und Stoppfunktionen direkt zu verwenden. Wenn dies nicht möglich ist, können Sie die Funktion aufrufen, um eine Dauer und die zugehörigen Metadaten und Annotationen aufzuzeichnen.

Gruppenfunktionen werden geladen

In Ihrem Spiel können Sie mehrere Ladeereignisse für einen einzelnen Ladezeitraum aufzeichnen, die der Nutzer sieht. Dazu gehören unter anderem das Laden von Dateien, die Dekomprimierung und die Shader-Kompilierung.

Es ist wichtig, Abstimmung Fork darüber zu informieren, dass Ladeereignisse Teil einer solchen Gruppe sind, damit sie bessere Einblicke liefern kann. Fügen Sie dazu die folgenden Start- und Stoppfunktionen in Ihre Ladeereignisse ein.

TuningFork_ErrorCode TuningFork_startLoadingGroup( const TuningFork_LoadingTimeMetadata* eventMetadata, uint32_t eventMetadataSize, const TuningFork_CProtobufSerialization* annotation, TuningFork_LoadingEventHandle* handle);

Diese Funktion startet eine Ladegruppe, die mit den angegebenen Metadaten und Annotationen verknüpft ist, und füllt eine handle aus, die in der Funktion TuningFork_stopLoadingGroup() verwendet werden soll. Die Metadaten und die Annotation werden derzeit nicht vom Play-Back-End verwendet und können auf nullptr gesetzt werden. Alle nachfolgenden Ladeereignisse werden mit einer eindeutigen Gruppen-ID gekennzeichnet.

TuningFork_ErrorCode TuningFork_stopLoadingGroup( TuningFork_LoadingEventHandle handle);

Diese Funktion stoppt eine Ladegruppe, die zuvor von TuningFork_startLoadingGroup() gestartet wurde. Nachfolgende Ladeereignisse haben erst dann eine Gruppen-ID, wenn TuningFork_startLoadingGroup() noch einmal aufgerufen wird.

Abbildung 1: Beispiel für die Ladegruppe.