SPUFS(7)

NOM
spufs - Le système de fichiers SPU

DESCRIPTION
Le système de fichiers SPU est utilisé sur les machines PowerPC à base de processeur « Cell Broadband Engine » afin d'accéder aux unités synergiques SPU (Synergistic Processor Units). Le système de fichiers fournit un espace de nom similaire à la mémoire partagée ou aux files de messages POSIX. Les utilisateurs qui ont les permissions d'écriture sur le système de fichiers peuvent utiliser spu_create(2) pour créer des contextes SPU dans le répertoire racine du système de fichiers SPU (spufs). Chaque contexte SPU est représenté par un répertoire contenant un ensemble prédéfini de fichiers. Ces fichiers peuvent être utilisés pour manipuler l'état de la SPU logique. Les utilisateurs peuvent modifier les permissions des fichiers, mais ne peuvent pas ajouter ou supprimer des fichiers.

  Options de montage

uid=<uid>
    Définir l'utilisateur propriétaire du point de montage ; la valeur par défaut est 0 (superutilisateur).

gid=<gid>
    Définir le groupe propriétaire du point de montage ; la valeur par défaut est 0 (superutilisateur).

mode=<mode>
    Définir le mode du répertoire de base dans spufs sous la forme d'une chaîne de valeur octale. La valeur par défaut est 0775.

  Fichiers
Les fichiers dans spufs suivent principalement le comportement standard pour les appels système comme read(2) ou write(2), mais ne supportent souvent qu'un sous-ensemble d'opérations supportées par les systèmes de fichiers normaux. La liste suivante détaille les opérations prises en charge ainsi que les déviations du comportement normal décrit dans leurs pages respectives. Tous les fichiers qui supportent les opérations de read(2) supportent également les opérations de readv(2), et tous les fichiers qui supportent les opérations de write(2) supportent également les opérations de writev(2). Tous les fichiers supportent les opérations des familles access(2) et stat(2), mais pour le dernier appel, les seuls champs de la structure stat renvoyée contenant une information fiable sont st_mode, st_nlink, st_uid et st_gid. Tous les fichiers supportent les opérations de chmod(2)/fchmod(2) et chown(2)/fchown(2), mais ne pourront pas accorder les permissions qui iraient en contradiction avec les opérations possibles (par exemple, l'accès en lecture du fichier wbox). L'ensemble actuel de fichiers est :

/capabilities
    Contient une chaîne, séparée par des virgules, représentant les capacités de ce contexte SPU. Les capacités possibles sont :

    sched
        Ce contexte peut être ordonnancé.

    step
        Ce contexte peut être exécuté en mode simple pas, pour débogage.

    De nouveaux attributs de capacités pourront être ajoutés dans le futur.

/mem
    le contenu de la mémoire de stockage locale de la SPU. On peut y accéder comme pour un fichier de mémoire partagée normal et il contient le code et les données de l'espace d'adressage de la SPU. Les opérations possibles sur un fichier mem ouvert sont :

    read(2), pread(2), write(2), pwrite(2), lseek(2)
        Ces appels fonctionnent comme d'habitude, hormis le fait que lseek(2), write(2) et pwrite(2) ne sont pas supportés au-delà de la fin de fichier. La taille du fichier est la taille du stockage local de la SPU, qui est normalement de 256 Ko.

    mmap(2)
        La projection de mem dans l'espace d'adressage du processus fournit un accès au stockage local de la SPU à l'intérieur de l'espace d'adressage du processus. Seules les projections MAP_SHARED sont autorisées.

/regs
    Contient les registres à vocation générale sauvegardés du contexte SPU. Ce fichier contient les valeurs 128 bits de chaque registre, du registre 0 au registre 127, dans l'ordre. Cela permet de consulter le contenu de ces registres à vocation générale à des fins de débogage. La lecture ou l'écriture dans ce fichier nécessite que le contexte ne soit pas ordonnancé, aussi, l'utilisation de ce fichier n'est pas recommandé lors de l'éxecution normale d'un programme. Le fichier regs n'existe pas pour les contextes créés avec l'attribut SPU_CREATE_NOSCHED.

/mbox
    La première boîte à lettres de la communication entre SPU et CPU. Ce fichier est en lecture seule et peut être lu en éléments de 4 octets. Ce fichier ne peut être utilisé qu'en mode non bloquant - même poll(2) ne peut pas être utiliser pour bloquer sur lui. La seule opération possible sur un fichier mbox ouvert est :

    read(2)
        Si count est inférieur à 4, read(2) renvoie -1 et écrit EINVAL dans errno. Si aucune donnée n'est disponible dans la boîte à lettres (c'est-à-dire, la SPU n'a pas envoyé de message dans la boîte à lettres), la valeur de retour vaut -1 et errno vaut EAGAIN. Lorsque des données ont été lues avec succès, quatre octets sont placés dans le tampon de données et la valeur 4 est renvoyée.

/ibox
    La seconde boîte à lettres de la communication entre SPU et CPU. Ce fichier est similaire au fichier de la première boîte à lettres, mais il peut être lu en mode d'entrées-sorties bloquantes, ainsi, appeler read(2) sur un fichier ibox ouvert bloquera tant que la SPU n'a pas écrit dans son canal boîte à lettres (à moins que le fichier n'ait été ouvert avec O_NONBLOCK, voir plus loin). Également, poll(2) et des appels système similaires peuvent être utilisés pour surveiller la présence de données dans la boîte à lettres. Les opérations possibles sur un fichier ibox ouvert sont :

    read(2)
        Si count est inférieur à 4, read(2) renvoie -1 et écrit EINVAL dans errno. Si aucune donnée n'est disponible dans la boîte à lettres et que le descripteur de fichier a été ouvert avec O_NONBLOCK, la valeur de retour est -1 et errno vaut EAGAIN. Si aucune donnée n'est disponible dans la boîte à lettres et que le descripteur de fichier a été ouvert sans O_NONBLOCK, l'appel bloquera jusqu'à ce que la SPU écrive dans son canal de boîte à lettres. Lorsque une donnée a été lue avec succès, quatre octets sont placés dans le tampon de données et la valeur 4 est renvoyée.

    poll(2)
        Sonder le fichier ibox renvoie (POLLIN | POLLRDNORM) même si une donnée est disponible en lecture.

/wbox
    La boîte à lettres de la communication entre CPU et SPU. Il est en écriture seule et peut être écrit en éléments de 4 octetts. Si la boîte à lettres est pleine, write(2) bloquera et poll(2) peut être utilisé pour bloquer jusqu'à ce qu'on puisse de nouveau écrire dans la boîte à lettres. Les opérations possibles sur un fichier wbox ouvert sont :

    write(2)
        Si count est inférieur à 4, write(2) renvoie -1 et écrit EINVAL dans errno. S'il n'y a pas d'espace disponible dans la boîte à lettres et que le descripteur de fichier a été ouvert avec O_NONBLOCK, la valeur de retour vaut -1 et errno vaut EAGAIN. S'il n'y a pas d'espace disponible dans la boîte à lettres et que le descripteur de fichier a été ouvert sans O_NONBLOCK, l'appel bloquera jusqu'à ce que la SPU lise son canal boîte à lettres PPE (PowerPC Processing Element). Lorsqu'une donnée a été écrite avec succès, l'appel système renvoie 4 comme résultat de fonction.

    poll(2)
        Un sondage du fichier wbox renvoie (POLLOUT | POLLWRNORM) même s'il y avait de la place disponible pour écrire.

/mbox_stat, /ibox_stat, /wbox_stat
    Ces fichiers en lecture seule contiennent la longueur de la file actuelle de chaque boîte à lettres, c'est-à-dire combien de mots peuvent être lus dans mbox ou ibox ou combien de mots peuvent être écrits dans wbox sans bloquer. Ces fichiers ne peuvent être lus que par éléments de 4 octets et renvoient un nombre entier binaire gros boutiste (big-endian). La seule opération possible sur un fichier *box_stat ouvert est :

    read(2)
        Si count est inférieur à 4, read(2) renvoie -1 et écrit EINVAL dans errno. Autrement, une valeur sur 4 octets est placée dans le tampon de données. Cette valeur est le nombre d'éléments qui peuvent être lus dans (pour mbox_stat et ibox_stat) ou écrits dans (pour wbox_stat) la boîte à lettres respective sans bloquer ou renvoyer une erreur EAGAIN.

/npc, /decr, /decr_status, /spu_tag_mask, /event_mask, /event_status, /srr0, /lslr
    Les registres internes de la SPU. Ces fichiers contiennent une chaîne de caractère ASCII représentant la valeur hexadécimale du registre spécifié. Lire et écrire dans ces fichiers (hormis npc, voir plus loin) nécessite que le contexte de la SPU ne soit pas ordonnancé, aussi, les accès fréquents à ces fichiers ne sont pas recommandés lors de l'éxecution normale d'un programme.

    Les contenus de ces fichiers sont :

    npc Compteur programme suivant - Valide uniquement lorsque la SPU est dans un étét arrêté.

    decr
        Décrémenteur SPU

    decr_status
        État du décrémenteur

    spu_tag_mask
        Masque de la balise MFC pour les DMA de la SPU

    event_mask
        Masque d'événements pour les interruptions de la SPU

    event_status
        Nombre d'événements SPU en attente (lecture seule)

    srr0
        Registre d'adresse de retour de l'interruption

    lslr
        Registre de limite de stokage local

    Les opérations possibles sur ces fichiers sont :

    read(2)
        Lit la valeur actuelle du registre. Si la valeur du registre est plus grande que le tampon passé à read(2), les lectures suivantes continueront à lire à partir du même tampon jusqu'à ce que la fin du tampon soit atteinte. Lorsqu'une chaîne complète a été lue, toutes les opérations de lecture suivantes renverront zéro octet et il faudra ouvrir un nouveau descripteur de fichier pour lire une nouvelle valeur.

    write(2)
        Une opération d'écriture write(2) dans le fichier écrit le registre avec la valeur fournie dans la chaîne. La chaîne est analysée du début jusqu'au premier caractère non numérique ou la fin du tampon. Les écritures suivantes sur le même descripteur de fichier écraseront les écritures précédentes. Excepté pour le fichier npc, ces fichiers n'existent pas dans les contextes créés avec l'attribut SPU_CREATE_NOSCHED.

/fpcr
    Ce fichier fournit un accès à l'état « virgule flottante » et au registre de contrôle sous forme d'un fichier binaire de 4 octets. Les opérations sur le fichier fpcr sont :

    read(2)
        Si count est inférieur à 4, read(2) renvoie -1 et écrit EINVAL dans errno. Autrement, une valeur sur 4 octets est placée dans le tampon de données ; c'est la valeur actuelle du registre fpcr.

    write(2)
        Si count est inférieur à 4, write(2) renvoie -1 et écrit EINVAL dans errno. Autrement, une valeur sur 4 octets est copiée du tampon de données, mettant à jour la valeur du registre fpcr.

/signal1, /signal2
    Ces fichiers fournissent un accès aux deux canaux de notification de signal d'une SPU. Ces fichiers en lecture-écriture travaillent avec des mots de 4 octets. L'écriture dans l'un de ces fichiers déclenche une interruption sur la SPU. La valeur écrite dans ces fichiers peut être lue par la SPU à travers une lecture du canal ou par l'espace utilisateur hôte à travers le fichier. Après que la valeur ait été lue par la SPU, le fichier est réinitialisé à zéro. Les opérations possibles sur un fichier signal1 ou signal2 ouvert sont :

    read(2)
        Si count est inférieur à 4, read(2) renvoie -1 et écrit EINVAL dans errno. Autrement, une valeur sur 4 octets est placée dans le tampon de données ; c'est la valeur actuelle du registre de notification de signal spécifié.

    write(2)
        Si count est inférieur à 4, write(2) renvoie -1 et écrit EINVAL dans errno. Une valeur sur 4 octets est copiée du tampon de données, mettant à jour la valeur actuelle du registre de notification de signal spécifié. Le registre de notification de signal sera soit remplacé par la donnée en entrée, soit mis à jour par un OU bit à bit entre l'ancienne valeur et la donnée en entrée, suivant, respectivement, le contenu des fichiers signal1_type ou signal2_type.

/signal1_type, /signal2_type
    Ces deux fichiers modifient le comportement des fichiers de notification signal1 et signal2. Ils contiennent une chaîne de caractères numériques ASCII qui peut être lue comme un « 1 » ou un « 0 ». Dans le mode 0 (écrasement), le matériel remplace le contenu du canal de signal par la donnée qui a été écrite dedans. Dans le mode 1 (OU logique), le matériel accumule les bits qui ont été écrits à la suite dedans. Les opérations possibles sur un fichier signal1_type ou signal2_type ouvert sont :

    read(2)
        Lorsque le compteur fourni à l'appel read(2) est plus court que la longueur nécessaire pour le nombre plus un caractère « nouvelle ligne », les lectures suivantes à partir du même descripteur de fichier complèteront la chaîne. Lorsqu'une chaîne complète est lue, toutes les opérations de lecture suivantes renverront zéro octet et il faudra ouvrir un nouveau descripteur de fichier pour lire à nouveau la valeur.

    write(2)
        Une opération write(2) sur le fichier écrit le registre avec la valeur donnée dans la chaîne. La chaîne est analysée du début jusqu'au premier caractère non numérique ou la fin du tampon. Les écritures suivantes sur le même descripteur de fichier écraseront les écritures précédentes.

/mbox_info, /ibox_info, /wbox_info, /dma_into, /proxydma_info
    Fichiers en lecture seule qui contiennent l'état sauvegardé des boîtes à lettres SPU et des files DMA. Cela permet de pourvoir consulter l'état de la SPU, principalement à des fins de débogage. les fichiers mbox_info et ibox_info contiennent chacun un message de 4 octets qui a été écrit par la SPU. Si aucun message n'a été écrit dans ces boîtes à lettres, le contenu de ces fichiers est indéterminé. Les fichiers mbox_stat, ibox_stat et wbox_stat contient le nombre de messages disponibles. Le fichier wbox_info contient un tableau de messages de 4 octets qui ont été envoyés à la SPU. Sur les machines CBEA actuelles, le tableau a une longueur de 4 éléments, ainsi, on peut lire jusqu'à 4 * 4 = 16 octets. Si une entrée de file de boîte à lettres est vide, les octets lus dans l'emplacement correspondant sont indéterminés. Le fichier dma_info contient le contenu de la file DMA du MFC de la SPU, représenté par la structure suivante :
    struct spu_dma_info {
        uint64_t         dma_info_type;
        uint64_t         dma_info_mask;
        uint64_t         dma_info_status;
        uint64_t         dma_info_stall_and_notify;
        uint64_t         dma_info_atomic_command_status;
        struct mfc_cq_sr dma_info_command_data[16];
    };
    Le dernier membre de cette structure de données est la file DMA réelle contenant 16 entrées. La structure mfc_cq_sr est définie ainsi :
    struct mfc_cq_sr {
        uint64_t mfc_cq_data0_RW;
        uint64_t mfc_cq_data1_RW;
        uint64_t mfc_cq_data2_RW;
        uint64_t mfc_cq_data3_RW;
    };
    Le fichier proxydma_info contient des informations similaires mais décrit la file DMA proxy (c'est-à-dire, les DMA initiés par des entités extérieures à la SPU). Le fichier a le format suivant :
    struct spu_proxydma_info {
        uint64_t         proxydma_info_type;
        uint64_t         proxydma_info_mask;
        uint64_t         proxydma_info_status;
        struct mfc_cq_sr proxydma_info_command_data[8];
    };
    L'accès à ces fichiers nécessite que le contexte SPU ne soit pas ordonnancé - l'utilisation fréquente serait inefficace. Ces fichiers ne doivent pas être utilisés dans l'exécution normale d'un programme. Ces fichiers n'existent pas dans les contextes créés avec l'attribut SPU_CREATE_NOSCHED.

/cntl
    Ce fichier fournit un accès aux registres de contrôle d'exécution et d'état de la SPU sous forme d'une chaîne ASCII. Les opérations suivantes sont prises en charge :

    read(2)
        La lecture du fichier cntl renverra une chaîne ASCCI contenant la valeur hexadécimale du registre d'état de la SPU.

    write(2)
        L'écriture dans le fichier cntl définira le registre de contrôle d'exécution du contexte de la SPU.

/mfc
    Fournit un accès au contrôleur de flux mémoire (MFC) de la SPU. Une lecture de ce fichier renvoie le contenu du registre d'état de balise MFC de la SPU et une écriture dans le fichier initie un DMA du MFC. Les opérations suivantes sont prises en charge :

    write(2)
        L'écriture dans ce fichier nécessite d'être dans le format d'une commande DMA du MFC défini ainsi :
        struct mfc_dma_command {
            int32_t  pad;    /* reserved */
            uint32_t lsa;    /* local storage address */
            uint64_t ea;     /* effective address */
            uint16_t size;   /* transfer size */
            uint16_t tag;    /* command tag */
            uint16_t class;  /* class ID */
            uint16_t cmd;    /* command opcode */
        };
        Les écritures doivent avoir une taille d'exactement sizeof(struct mfc_dma_command) octets. La commande sera envoyée à la file proxy MFC de la SPU et la balise enregistrée dans le noyau (voir plus loin).

    read(2)
        Lire le contenu du registre d'état de balise. Si le fichier est ouvert en mode bloquant (c'est-à-dire, sans O_NONBLOCK), la lecture bloquera jusqu'à ce qu'une balise DMA (comme effectué par une écriture précédente) soit achevée. En mode non bloquant, le registre d'état de balise MFC sera renvoyé sans attente.

    poll(2)
        Appeler poll(2) sur le fichier mfc bloquera jusqu'à ce qu'un nouveau DMA puisse être démarré (en vérifiant POLLOUT) ou jusqu'à ce qu'un DMA démarré précédemment (en vérifiant POLLIN) ne soit achevé. /mss Fournit un accès à la fonctionnalité de synchronisation multisource (MSS) MFC. En effectuant un mmap(2) sur ce fichier, les processus peuvent accéder à la zone MSS de la SPU. Les opérations suivantes sont prises en charge :

    mmap(2)
        La projection de mss dans l'espace d'adressage du processus donne un accès à la zone MSS de la SPU dans l'espace d'adressage du processus. Seules les projections MAP_SHARED sont autorisées.

/psmap
    Fournit un accès à l'ensemble de la projection d'état de problèmes de la SPU. Les applications peuvent utiliser cette zone pour interfacer la SPU plutôt que d'écrire dans les fichiers individuels des registres sur le système de fichier spufs. Les opérations suivantes sont prises en charge :

    mmap(2)
        La projection psmap donne à un processus une projection directe de la zone d'état de problèmes de la SPU. Seules les projections MAP_SHARED sont prises en charge.

/phys-id
    Fichier en lecture seule contenant le nombre de SPU physiques sur lesquelles s'exécutent le contexte SPU. Lorsque le contexte n'est pas en cours d'exécution, ce fichier contient la chaîne « -1 ». Le nombre de SPU physiques est fourni sous forme d'une chaîne ASCII hexadécimale.

/object-id
    Permet aux applications de stocker (ou récupérer) un idendifiant 64 bits dans le contexte. Cet identifiant est utilisé plus tard par les outils de profilage pour identifier de manière unique le contexte.

    write(2)
        En écrivant une valeur hexadécimale ASCII dans ce fichier, les applications peuvent définir l'identifiant d'objet du contexte SPU. Toute valeur précédente de l'identifiant d'objet est écrasée.

    read(2)
        La lecture de ce fichier fournit une chaîne hexadécimale ASCII représentant l'identifiant d'objet de ce contexte SPU.

EXEMPLE

/etc/fstab  entry
    none      /spu      spufs      gid=spu      0    0

VOIR AUSSI
close(2), spu_create(2), spu_run(2), capabilities(7), The Cell Broadband Engine Architecture (CBEA) specification

TRADUCTION

Ce document est une traduction réalisée par Alain Portal <aportal AT univ-montp2 DOT fr> le 18 décembre 2007 et révisée le 14 janvier 2008.

L'équipe de traduction a fait le maximum pour réaliser une adaptation française de qualité. La version anglaise la plus à jour de ce document est toujours consultable via la commande : « LANG=C man 7 spufs ». N'hésitez pas à signaler à l'auteur ou au traducteur, selon le cas, toute erreur dans cette page de manuel.