Planification des charges de travail

Sous Android 17 et versions ultérieures, le gestionnaire de l'unité de traitement neuronal (NPU) coordonne le contrôle d'admission des modèles et la priorité des charges de travail entre les applications et les services système. Plutôt que de laisser les tâches en arrière-plan priver de ressources les tâches de premier plan sensibles à la latence, le service système npu suit les états du cycle de vie des applications à partir de ActivityManager et transmet des règles de planification efficaces au pilote NPU du fournisseur via la couche d'abstraction matérielle (HAL) du langage de définition d'interface Android (AIDL) android.hardware.npu.

API de framework pour l'arbitrage du chargement des modèles

Avant d'appeler des bibliothèques de réseaux de neurones de bas niveau ou de charger des fichiers de modèle volumineux, les clients du framework interagissent avec android.npumanager.NpuManager pour réserver de la capacité de modèle. NpuManager est une API système (@SystemApi), et non une API de SDK d'application publique. Les appelants doivent disposer de l'autorisation android.permission.ACCESS_NPU_MODEL_MANAGER_API. Les clients créent d'abord une requête de chargement de modèle, puis exécutent le flux de requête et d'approbation asynchrone.

Créer une requête de chargement de modèle

Une réservation de chargement de modèle est représentée par ModelLoadRequest. Cet objet contient les paramètres suivants :

  • Identifiant de requête unique
  • Classe de taille de modèle estimée : NPU_MODEL_SIZE_LESS_THAN_1GB, NPU_MODEL_SIZE_BETWEEN_1GB_AND_2GB ou NPU_MODEL_SIZE_GREATER_THAN_2G
  • Priorité de la charge de travail prévue, telle que NPU_MODEL_PRIORITY_BACKGROUND, NPU_MODEL_PRIORITY_NORMAL ou NPU_MODEL_PRIORITY_OPPORTUNISTIC

L'exemple Java suivant crée un ModelLoadRequest pour un modèle de plus de 2 Go avec une priorité d'exécution normale :

ModelLoadRequest request = new ModelLoadRequest.Builder(requestId)
        .setSize(NPU_MODEL_SIZE_GREATER_THAN_2G)
        .setPriority(NPU_MODEL_PRIORITY_NORMAL)
        .build();

Exécuter le flux de demande et d'approbation

Les clients envoient la réservation de manière asynchrone à l'aide de la méthode requestCanLoadModel :

npuManager.requestCanLoadModel(request, callback, executor);

Lorsque la capacité du NPU est évaluée ou que la pression du système change, le framework en informe le client via ModelLoadRequestCallback avec les événements suivants :

  • onCanLoadModel(request, status, listener) : déclenché lorsque la demande est approuvée. Le client reçoit un jeton NpuManager.ModelLoadStatusListener. Après avoir chargé le modèle dans la mémoire du NPU, le client doit appeler listener.notifyModelLoaded(request).
  • onRequestUnloadModel(request) ou onRequestUnloadModel(request, reason) : déclenché lorsque le système rencontre un conflit de ressources, tel qu'une charge de travail entrante au premier plan ou un pic thermique, et nécessite que le client libère son modèle. Après avoir libéré les ressources du NPU, le client doit appeler listener.notifyModelUnloaded(request).
  • onModelLoadRequestComplete(request, status) : informe le client des transitions du cycle de vie des requêtes de terminal, telles que l'annulation.

Les clients peuvent annuler les requêtes en attente à tout moment en appelant cancelModelLoad(request).

Intégration de la HAL de planification

Les implémentations de fournisseurs spécifiques à l'appareil s'intègrent au planificateur de la plate-forme en implémentant l'interface de service IScheduling.aidl dans le package android.hardware.npu.

Configurer les priorités d'UID et le contrôle des accès

Le service système npu transmet les valeurs de priorité et les règles d'accès par UID au HAL du fournisseur à l'aide de setSchedulingConfigs et updateSchedulingConfigs avec l'objet Parcelable SchedulingConfig.aidl :

package android.hardware.npu;

@VintfStability
parcelable SchedulingConfig {
    const int MIN_PRIORITY = 0;
    const int MAX_PRIORITY = 1000;
    int uid;
    int priority;
    boolean hasDirectAccess;
    boolean canAttributeOtherUid;
}

Chaque champ de SchedulingConfig contrôle la manière dont le pilote de NPU du fournisseur arbitre le travail envoyé par un identifiant utilisateur (UID) :

Champ ou constante Description
MIN_PRIORITY et MAX_PRIORITY Limites de priorité valides (0 à 1000), où MIN_PRIORITY (0) représente la priorité de planification la plus élevée et MAX_PRIORITY (1000) représente la priorité de planification la plus faible.
uid UID Linux de l'application cliente ou du service système.
priority Score d'importance de la plate-forme compris entre 0 et 1000, où 0 correspond à la priorité la plus élevée. Dérivé de l'état du processus ActivityManager, de sorte que les applications de premier plan l'emportent sur les processus mis en cache ou en arrière-plan.
hasDirectAccess Indique si uid est autorisé à ouvrir des sessions d'exécution directe du NPU. Si la valeur est false, la création ou l'exécution de la session directe échoue avec EX_SECURITY.
canAttributeOtherUid Indique si un service intermédiaire privilégié, tel qu'AICore, est autorisé à attribuer l'utilisation du NPU et de l'alimentation à un client appelant originalUid.

Les planificateurs de NPU des fournisseurs doivent calculer une priorité effective comprise entre 0 et 2000 (où 0 est la priorité la plus élevée) en ajoutant SchedulingConfig.priority (0 à 1000) à la priorité de la tâche demandée par le client, normalisée entre 0 et 1000, et planifier les files d'attente d'exécution matérielle en fonction de cette priorité effective. Par exemple, si une application en arrière-plan envoie une tâche de priorité élevée, son score priority plus élevé réduit sa priorité effective (produisant une valeur numérique plus élevée) afin de ne pas retarder les charges de travail de l'appareil photo ou de l'UI au premier plan.

Signaler l'état et l'attribution des tâches

Les pilotes du fournisseur signalent le cycle de vie des groupes d'exécution de NPU à la plate-forme à l'aide de WorkInfo.aidl :

package android.hardware.npu;

import android.hardware.npu.Uuid;

@VintfStability
parcelable WorkInfo {
    int id;
    @nullable Uuid groupId;
    int uid;
    int debugPid;
    int originalUid;
    @nullable String debugFeatureId;
    int jobPriority;
    int effectivePriority;
    long timestampMs;
    int deviceNumber;
}

Lorsqu'un service intermédiaire avec canAttributeOtherUid activé exécute un modèle pour le compte d'une application cliente, originalUid contient l'UID de l'application d'origine, tandis que uid identifie le service d'envoi. Cette séparation permet à la télémétrie de la plate-forme et à la comptabilisation de l'alimentation de facturer le travail à l'application à l'origine de la requête plutôt qu'au daemon intermédiaire.

Configurer l'anti-rebond des événements

Lorsqu'un écouteur ISchedulingCallback est enregistré auprès de IScheduling.setCallback, la HAL élimine les rebonds des notifications de travail associées sur au moins ISchedulingCallback.DEBOUNCE_DURATION_MS (50 ms). Les éléments de travail sont considérés comme liés lorsqu'ils partagent les mêmes uid, originalUid et debugFeatureId, ou le même groupId. Le debouncing supprime les tempêtes de rappels rapides lors des exécutions d'inférence en streaming ou en plusieurs étapes, ce qui réduit la surcharge de Binder et l'inondation des journaux.

Les états du cycle de vie du rappel sont signalés par trois méthodes sur ISchedulingCallback :

  • onWorkRequested : la charge de travail est reçue par le service ou le pilote du fournisseur.
  • onWorkStarted : l'exécution matérielle commence, taguée avec un StartReason :
    • StartReason.INITIAL : exécution initiale d'une nouvelle requête d'application.
    • StartReason.RESUMED : l'exécution a repris après avoir été mise en pause (PAUSED).
  • onWorkEnded : l'exécution du matériel s'arrête après l'écoulement de DEBOUNCE_DURATION_MS sans travail de suivi associé, tagué avec un EndReason :
    • EndReason.COMPLETED : l'exécution s'est terminée normalement.
    • EndReason.CANCELLED_USER : exécution annulée par l'application appelante.
    • EndReason.CANCELLED_SYSTEM : exécution préemptée et annulée par une tâche de priorité plus élevée.
    • EndReason.PAUSED : l'exécution est temporairement suspendue pour exécuter des tâches de priorité plus élevée et peut reprendre avec StartReason.RESUMED.
    • EndReason.FAILED : l'exécution a échoué en raison d'une erreur de pilote ou de matériel.

Validation

Validez les implémentations de planification de NPU à l'aide des suites de tests suivantes :

  • Suite de tests du fournisseur (VTS) : exécutez VtsHalNpuSchedulingTargetTest (empaqueté dans VtsHalNpuTargetTest) pour vérifier les mises à jour de configuration de IScheduling, l'ordre de priorité effectif, les règles d'attribution d'UID et la fonctionnalité anti-rebond de ISchedulingCallback.
  • Compatibility Test Suite (CTS) : exécutez CtsNpuManagerMoblyTestCases pour vérifier la priorisation de bout en bout des charges de travail NPU au premier plan par rapport à l'arrière-plan. Pour obtenir des instructions de configuration des tests, consultez Exécuter des tests Mobly du gestionnaire de NPU.