Couche d'abstraction Cgroup

Android 10 ou version ultérieure utilise un groupe de contrôle (cgroup) couche d'abstraction avec des profils de tâche, que les développeurs peuvent utiliser pour décrire un ensemble (ou ensembles) de restrictions à appliquer à un thread ou à un processus. Le système suit les actions prescrites par les profils de tâches pour sélectionner une ou plusieurs cgroups appropriés, via lesquels les restrictions sont appliquées, et les modifications l'ensemble de caractéristiques cgroup sous-jacent peut être créé sans affecter les logiciels plus élevés couches.

À propos des cgroups

Les cgroups fournissent un mécanisme permettant d'agréger et de partitionner des ensembles de tâches (qui se composent de processus, de threads et de tous leurs futurs enfants) en groupes hiérarchiques avec un comportement spécialisé. Android utilise des cgroups pour contrôler et tenir compte des ressources système telles que l'utilisation et l'allocation de processeurs et de mémoire, Noyau Linux cgroups v1 et cgroups v2.

Android 9 ou version antérieure

Dans Android 9 et versions antérieures, le script d'initialisation init.rc contenait l'ensemble des les cgroups disponibles, leurs points d'installation et leurs versions. Bien qu’il puisse s’agir modifié, le framework Android s'attendait à ce qu'un ensemble spécifique de cgroups existe des emplacements spécifiques avec une version et une hiérarchie de sous-groupes spécifiques, en fonction script. Cela limitait la possibilité de choisir la prochaine version de cgroup à utiliser, ou de modifier la hiérarchie cgroup pour utiliser de nouvelles caractéristiques.

Android 10 ou version ultérieure

Android 10 et versions ultérieures utilisent des cgroups avec des profils de tâches:

  • Configuration du groupe Cgroup. Les développeurs décrivent la configuration des cgroups dans leur cgroups.json pour définir des ensembles de cgroups, ainsi que leurs emplacements et attributs d'installation. Tous les cgroups sont installés pendant la phase d'initialisation au démarrage de l'initialisation. processus.
  • Profils de tâches. Ils fournissent une abstraction qui dissocie les des détails de son implémentation. Le framework Android applique les profils de tâche comme décrit dans le fichier task_profiles.json à un ou thread à l'aide des API SetTaskProfiles et SetProcessProfiles. (Ces API sont propres à Android 11 et versions ultérieures.)

Pour assurer la rétrocompatibilité, les anciennes fonctions set_cpuset_policy, set_sched_policy et get_sched_policy fournissent la même API et les mêmes fonctionnalités, mais leur implémentation a été modifiée pour utiliser des profils de tâches. Nouvel usage cas. AOSP recommande d'utiliser de nouvelles API de profils de tâche plutôt que les anciennes fonction set_sched_policy.

Fichier de description des cgroups

Les cgroups sont décrits dans le cgroups.json situé sous <ANDROID_BUILD_TOP>/system/core/libprocessgroup/profiles/. Chaque manette est décrite dans une sous-section et doit disposer au minimum des éléments suivants:

  • Nom défini par le champ Controller (Contrôleur).
  • Chemin d'installation défini par le champ Chemin d'accès
  • le mode, l'UID (ID utilisateur) et le GID (ID du groupe) décrivant le propriétaire et des modes d'accès aux fichiers sous ce chemin (tous facultatifs).
  • Attribut facultatif, défini sur true pour permettre au système d'ignorer l'installation causée par un contrôleur cgroup que le noyau ne prend pas en charge l’installation.

Exemple de fichier cgroups.json

L'exemple ci-dessous montre les descriptions de cgroup v1 (Cgroups) et cgroup v2 (Cgroups2) avec leurs chemins d'accès respectifs.

{
  "Cgroups": [
    {
      "Controller": "cpu",
      "Path": "/dev/cpuctl",
      "Mode": "0755",
      "UID": "system",
      "GID": "system"
    },
    {
      "Controller": "memory",
      "Path": "/dev/memcg",
      "Mode": "0700",
      "Optional": true
    }
  ],
 "Cgroups2": {
   "Path": "/sys/fs/cgroup",
   "Mode": "0755",
   "UID": "system",
   "GID": "system",
   "Controllers": [
     {
       "Controller": "freezer",
       "Path": ".",
       "Mode": "0755",
       "UID": "system",
       "GID": "system"
     }
   ]
 }
}

Cet exemple de fichier contient deux sections, Cgroups (décrivant le groupe cgroup v1) contrôleurs) et Cgroups2 (décrivant les contrôleurs cgroup v2). Tout les contrôleurs de la hiérarchie cgroups v2 sont installés au même endroit. Par conséquent, la section Cgroups2 possède ses propres chemin d'accès, mode, UID et GID pour décrire l'emplacement et les attributs de la racine du la hiérarchie. L'attribut Path pour les contrôleurs sous Cgroups2 est par rapport à ce chemin d'accès racine. Sous Android 12 ou version ultérieure, vous pouvez définir un cgroup contrôleur dont le chemin d'accès et le mode sont définis sur "Optional" en la définissant sur true.

Le fichier cgroups.json est analysé dans le cadre du processus d'initialisation, lors de l'initialisation préliminaire. et les cgroups sont installés aux emplacements spécifiés. Pour obtenir les emplacements d'installation cgroup, utilisez la fonction d'API CgroupGetControllerPath ;

Fichier de profils de tâche

task_profiles.json fichier se trouve sous <ANDROID_BUILD_TOP>/system/core/libprocessgroup/profiles/. Utilisez-le pour décrire un ensemble spécifique d'actions à appliquer à un processus ou à une thread. Un ensemble d'actions est associé à un nom de profil, qui est utilisé dans Appels SetTaskProfiles et SetProcessProfiles pour appeler des actions de profil.

Exemple de fichier task_profiles.json

{
  "Attributes": [
    {
      "Name": "MemSoftLimit",
      "Controller": "memory",
      "File": "memory.soft_limit_in_bytes"
    },
    {
      "Name": "MemSwappiness",
      "Controller": "memory",
      "File": "memory.swappiness"
    }
  ],
  "Profiles": [
    {
      "Name": "MaxPerformance",
      "Actions" : [
        {
          "Name" : "JoinCgroup",
          "Params" :
          {
            "Controller": "schedtune",
            "Path": "top-app"
          }
        }
      ]
    },
    {
      "Name": "TimerSlackHigh",
      "Actions" : [
        {
          "Name" : "SetTimerSlack",
          "Params" :
          {
            "Slack": "40000000"
          }
        }
      ]
    },
    {
      "Name": "LowMemoryUsage",
      "Actions" : [
        {
          "Name" : "SetAttribute",
          "Params" :
          {
            "Name" : "MemSoftLimit",
            "Value" : "16MB"
          }
        },
        {
          "Name" : "SetAttribute",
          "Params" :
          {
            "Name" : "MemSwappiness",
            "Value" : "150"

          }
        }
      ]
    }
  ]
  "AggregateProfiles": [
     {
       "Name": "SCHED_SP_DEFAULT",
       "Profiles": [ "TimerSlackHigh", "MaxPerformance" ]
     },
     {
       "Name": "SCHED_SP_BACKGROUND",
       "Profiles": [ "LowMemoryUsage" ]
     }
}

Attribuez un nom à des fichiers cgroup spécifiques dans la liste Attributs. Chaque entrée contient les éléments suivants:

  • Le champ Name (Nom) indique le nom de l'attribut.
  • Le champ Controller fait référence à un contrôleur cgroup du cgroups.json. par son nom.
  • Le champ File (Fichier) nomme un fichier spécifique de ce contrôleur.

Les attributs sont des références dans les définitions de profil de tâche. En dehors de la tâche utilisez-les uniquement lorsque le framework nécessite un accès direct à ces et les accès ne peuvent pas être abstraits à l'aide de profils de tâches. Dans tous les autres cas, utiliser des profils de tâches ; ils permettent un meilleur découplage entre le comportement requis ses détails d'implémentation.

La section Profils contient les définitions de profil de tâche suivantes:

  • Le champ Nom définit le nom du profil.

  • La section Actions répertorie un ensemble d'actions effectuées lorsque le profil est appliquée. Chaque action se compose des éléments suivants:

    • Le champ Name (Nom) spécifie l'action.
    • La section Paramètres spécifie un ensemble de paramètres pour l'action.

Les actions disponibles sont répertoriées dans le tableau:

Action Paramètre Description
SetTimerSlack Slack Retard du minuteur en ns
SetAttribute Name Nom faisant référence à un attribut de la section Attributs
Value Valeur à écrire dans le fichier représenté par l'attribut nommé
WriteFileFilePathchemin d'accès au fichier
Valueune valeur à écrire dans le fichier
JoinCgroup Controller Nom du contrôleur cgroup de cgroups.json
Path Chemin d'accès à un sous-groupe dans la hiérarchie du contrôleur cgroup

Android 12 et versions ultérieures disposent d'un élément AggregateProfiles qui contient des profils agrégés, chacun étant un alias pour un ensemble de un ou plusieurs profils. Les définitions de profil agrégées se composent des éléments suivants:

  • Le champ Name (Nom) indique le nom du profil agrégé.
  • Profils répertorie les noms des profils inclus dans les profil agrégé.

Lorsqu'un profil agrégé est appliqué, tous les profils associés sont également automatiquement appliquée. Les profils agrégés peuvent contenir à la fois des profils individuels ou d'autres profils agrégés, à condition qu'il n'y ait pas de récursions (un profil qui inclut l'image elle-même).

Commande init language task_profiles

Une commande task_profiles en langage d'initialisation Android est disponible pour Android 12 ou version ultérieure afin de faciliter l'activation du profil de tâche pour un processus spécifique. Elle remplace les writepid (obsolète dans Android 12) qui permettait de migrer entre des cgroups. La commande task_profiles offre une certaine flexibilité pour en modifiant les implémentations sous-jacentes sans que cela ait d'incidence sur les couches supérieures. Dans dans l'exemple ci-dessous, ces deux commandes effectuent en fait la même opération:

  • writepid /dev/cpuctl/top-app/tasks

    Obsolète dans Android 12, il était utilisé pour écrire le PID. de la tâche en cours dans le fichier /dev/cpuctl/top-app/tasks.

  • task_profiles MaxPerformance

    Joint le processus en cours au groupe "top-app" sous "cpu" contrôleur (cpuctl), ce qui entraîne l'écriture du PID du processus dans dev/cpuctl/top-app/tasks

Utilisez toujours la commande task_profiles pour migrer des tâches dans des hiérarchies cgroup dans Android 12 ou version ultérieure. Il accepte un ou plusieurs paramètres, représentant le noms des profils spécifiés dans le fichier task_profiles.json.

Profils de tâches au niveau de l'API

Sur Android 12 ou version ultérieure, vous pouvez modifier ou ignorer dans les fichiers cgroups.json et task_profiles.json par défaut, soit Baser votre modification sur le niveau d'API Android ou la faire passer par le fournisseur partition.

Pour remplacer les définitions en fonction du niveau d'API, les fichiers suivants doivent être présentes sur l'appareil:

  • /system/etc/task_profiles/cgroups_<API level>.json

    Utilisez cette option pour les cgroups spécifiques à un niveau d'API.

  • /system/etc/task_profiles/task_profiles_<API level>.json

    Utilisez cette option pour les profils spécifiques à un niveau d'API.

Pour remplacer les définitions de la partition des fournisseurs, les fichiers suivants doivent être présentes sur l'appareil:

  • /vendor/etc/cgroups.json
  • /vendor/etc/task_profiles.json

Si un attribut ou une définition de profil dans ces fichiers utilise le même nom que se trouve dans le fichier par défaut, la définition du fichier (au niveau de l'API ou du fournisseur) remplace à la définition précédente. Notez également que les définitions au niveau du fournisseur remplacent Définitions au niveau de l'API. Si la nouvelle définition a un nouveau nom, alors l'ensemble des ou profils est modifié par cette nouvelle définition.

Le système Android charge les fichiers cgroup et task_profile dans cet ordre:

  1. Par défaut : cgroups.json et task_profiles.json .
  2. Fichiers spécifiques au niveau de l'API, le cas échéant.
  3. Fichiers de partition du fournisseur, le cas échéant.

Modifications apportées à l'API existante

Android 10 et versions ultérieures conservent les fonctions set_cpuset_policy, set_sched_policy et get_sched_policy sans modifier l'API. Cependant, Android 10 déplace ces fonctions dans libprocessgroup, qui contient désormais toutes les fonctionnalités liées à cgroup.

Bien que l'en-tête cutils/sched_policy.h existe toujours, pour éviter de perturber code existant pour s'assurer que le nouveau code inclut un nouveau processgroup/sched_policy.h à la place.

Les modules qui utilisent l'une de ces fonctions doivent ajouter une dépendance libprocessgroup dans son fichier makefile. Si un module n'utilise pas d'autre Fonctionnalité libcutils, suppression de libcutils bibliothèque du fichier makefile.

API de profils de tâche

Les API privées de processgroup/processgroup.h sont définies dans le tableau suivant:

Type API et définition
bool SetTaskProfiles(int tid, const std::vector& profiles)
Applique les profils de tâches spécifiés dans profiles au thread spécifié par Un ID de thread (tid) à l'aide de son paramètre tid.
bool SetProcessProfiles(uid_t uid, pid_t pid, const std::vector& profiles)
Applique les profils de tâches spécifiés dans profiles au processus spécifié. par ses ID d'utilisateur et de processus à l'aide des paramètres uid et pid
bool CgroupGetControllerPath(const std::string& cgroup_name, std::string* path)
Indique si un contrôleur cgroup spécifié par cgroup_name existe. Si la valeur est true, définit la variable path sur la racine de ce groupe de configuration.
bool CgroupGetAttributePath(const std::string& attr_name, std::string* path)
Indique si un attribut de profil spécifié par attr_name existe. si true définit la variable path sur le chemin du fichier associé à cet attribut de profil.
bool CgroupGetAttributePathForTask(const std::string& attr_name, int tid, std::string* path)
Indique si un attribut de profil spécifié par attr_name existe. si true définit la variable path sur le chemin du fichier associé à cet attribut de profil et au fil de discussion spécifié par son identifiant à l'aide de le paramètre tid.
bool UsePerAppMemcg()
Indique si le système est configuré pour utiliser des cgroups de mémoire par application.