Chapitre 11 : Calcul en virgule flottante et nombres pseudo aléatoires

Pour effectuer des calculs en virgule flottante en utilisant les instructions assembleur, le programme ci après va consister à générer des nombres pseudo aléatoires et à calculer la moyenne, l’écart type et le khi afin de vérifier la validité du générateur.

Je dois vous avouer que ce générateur est très simple et donc que les nombres générées ne sont pas très aléatoires (voir la théorie sur la génération de ces nombres et les livres de Knuth).

Le programme vous semble aussi très long mais j’ai voulu afficher les résultats en écrivant une routine d’affichage des nombres en virgule flottante simple précision et c’est assez compliqué (et certainement cette routine peut être améliorée).

ATTENTION remarque du 10/09/2020 : la routine d'affichage est fausse pour de grands exposants (certainement > 32). Une nouvelle routine pour les nombres en double précision est en cours de test et sera publiée dans le chapitre 90. Le chapitre 88 donne une routine qui semble plus exacte à ce jour pour l'assembleur 64 bits.

  

Lors de la première compilation de ce programme, le compilateur signale que les instructions en virgule flottante ne sont pas autorisées sur le processeur de mon Raspberry. Alors que la documentation précise bien que c’est possible et donc après recherche, j’ai découvert qu’il fallait ajouter la directive suivante

-mcpu=arm1176jzf-s -mfpu=vfp -mfloat-abi=hard

dans le script d’assemblage. Donc j’ai écrit un nouveau script de compilation et j’ai aussi modifié le link pour qu’il s’exécute par gcc car le programme fait aussi appel à la fonction printf du C.

Voyons le source du programme :

Après les déclarations habituelles des messages et des zones nécessaires, nous initialisons les registres nécessaires au calcul. En virgule flottante simple précision, nous trouvons de nouveaux registres s0 à s31 et en double précision les registres d0 à d15 ( mais attentions les registres d recouvrent les registres s. Voir le chapitre 13 sur http://thinkingeek.com/arm-assembler-raspberry-pi/). Nous allons effectuer les calculs en simple précision et donc nous utiliserons les registres s. Pour alimenter s3, il suffit de copier le registre r0 par l’instruction vmov s3,r0  puis il faut effectuer une conversion par l’instruction vcvt.f32.s32 s3, s3  (f32 et s32 indique que nous travaillons en simple précision) car les nombres ont une structure très particulière : norme IEEE754.

En simple précision, les nombres font 32 bits : le bit à gauche donne le signe puis les 8 bits suivants représentent l’exposant et les 23 derniers bits la mantisse (pour plus de précisions voir la norme IEEE754)

Après avoir initialisé les 3 registres s2, s3 et s4 (surtout de jamais oublier d’effectuer la conversion). Nous préparons une table qui va compter le nombre de tirage pour un chiffre aléatoire tiré, table nécessaire pour le calcul du KHI.

Puis nous avons une boucle qui va effectuer MAXI tirages en appelant la fonction de génération. Nous passons à cette fonction la valeur PLAGE et nous aurons en retour dans r0 un nombre pseudo aléatoire compris entre 0 et PLAGE. La fonction de génération est simple puisque nous nous contentons de multiplier une graine de départ par un nombre donné et d’y ajouter un autre nombre pour calculer une nouvelle graine. Ensuite nous effectuons une division par la plage demandée et nous retournons le reste comme nombre aléatoire.

 Nous copions ce nombre dans le registre s1, et effectuons sa conversion pour le diviser par le nombre de tirage et l’ajouter dans le registre de totalisation de la moyenne avec les instructions de calcul en virgule flottante (vdiv, fmul, fadd ). Nous calculons aussi l’écart type en virgule flottante. Et pour chaque tirage, nous l’ajoutons aussi dans la table des tirages.

En fin de boucle, nous calculons la moyenne en nombre entier (en fait simplement pour voir la différence avec le calcul en virgule flottante) et nous l’affichons par notre fonction d’affichage, nous terminons le calcul de l’écart type (élévation au carré et calcul de la racine carrée) et nous l’affichons avec la fonction printf du C. Mais cette fonction n’admet que les nombres en double précision passés dans les registres r2 et r3. Il nous faut donc convertir notre résultat par l’instruction vcvt.f64.f32  d5, s3  (noter le f64 et l’utilisation du registre d5) puis alimenter les registres par vmov r2,r3,d5 pour appeler la fonction du C printf. Cette fonction utilise le format %f pour éditer correctement le nombre indiqué dans la chaine szFormat.

Ensuite nous appelons la routine conversionFloatSP pour convertit le contenu du registre r0 en chaine affichable. J’ai écrit cette routine pour ne pas faire appel à des fonctions du C. Comme je ne suis pas encore un expert en assembleur, cette routine n’est certainement pas l’idéal et il reste des points à améliorer (en particulier les zéros inutiles après la virgule. Elle est aussi compliquée car pour calculer le résultat qui dépasse la taille d’un registre, je suis passé par des zones en mémoire pour effectuer les multiplications et divisions nécessaires. Sur Internet, je n’ai pas trouvé d’exemples de routines en assembleur qui effectuent cette conversion et j’ai dû écrire la mienne à partir de la documentation du format IEEE754.

La routine commence par extraire l’exposant et la mantisse du registre r0 et en fonction de l’exposant va effectuer 4  traitements différents : l’exposant est égal à 255 , l’exposant est égal à 0, l’exposant est supérieur à 127 et l’exposant est inférieur à 127. Pour la suite de la routine, je vous suggère d’aller voir directement le code et les commentaires.

Revenons dans le programme principal pour calculer le coefficient khi  qui permet de juger de la pertinence du générateur aléatoire. Nous repartons de la table dans laquelle nous avons enregistré les comptages de chaque tirage  pour calculer le total des carrés de chaque compteur. Ensuite nous effectuons le reste des calculs en virgule flottante pour afficher le résultat avec la fonction printf du C et avec la routine en assembleur.

Voici le résultat sur mon raspberry :

Comme vous le voyez, la moyenne, l’écart type et le khi sont proches de ceux attendus (50 , 25 et 100).

Pour les calculs en virgule flottante, les instructions à utiliser ne sont pas très complexes, il faut surtout veiller à bien mettre les bonnes extensions .f32.s32  et pensez à effectuer les conversions entier vers float.

Et dans ce programme, je n’ai pas fait appel à des données en virgule flottante. Si c’est nécessaire il faut les coder comme ceci :

pi: .float 0E-3141592E-6

et l’utiliser par ldr r1,=pi

                           vldr s1,[r1]         @ s1 contient pi

et dans ce cas il est inutile d’effectuer la conversion par l’instruction vcvt.

Exercice : tester  un générateur diffèrent pour avoir un khi meilleur

                Améliorer la routine de conversion du nombre en simple précision

              Et plus difficile, écrire une routine de conversion pour les nombres en double précision.

               Et aussi une routine pour saisir dans la console des nombres en virgule flottante.

Chapitre 10 : lecture d'un répertoire

Si avec le programme de lecture du chapitre 8, nous essayons de lire un répertoire, nous avons une erreur qui indique que le fichier lu n’est pas un fichier mais un répertoire !! Donc il nous faut trouver un autre appel système qui traite les répertoires. Nous trouvons un READDIR code 89 mais un premier test retourne une erreur -38 : appel non implémenté. Enfin nous trouvons un appel GETDENTS code 8D qui fonctionne. Cet appel donne à l’adresse passée dans le registre r1 une structure qui contient des entrées composées entre autres de l’identification des fichiers et leurs noms. Pour certainement un gain de place, les noms ne sont pas stockés dans une zone de longueur fixe mais dans une zone de longueur variable. Ainsi pour connaitre l’emplacement de début de l’entrée suivante chaque entrée contient le déplacement (offset) qui permet d’aller à l’entrée suivante.

Voyons ce petit programme qui accède à un répertoire, qui affiche le nom de chaque fichier qui compose le répertoire et son type. Voici le lien vers le source du programme lectdir2.s.

Tout d’abord, nous trouvons une série de constantes pour les types des fichiers possibles puis les libellés des messages d’erreurs ou de résultats et la description de la structure utilisée.

Dans la partie code, nous effectuons comme précédemment l’ouverture du répertoire puis la lecture des données dans un buffer avec l’appel GETDENTS. Nous affichons le contenu de ce buffer par notre routine habituelle de vidage pour vérification puis nous entrons dans une boucle qui va afficher le nom du fichier. Ce nom est récupéré grâce à l’instruction : add r0,r2,#Dir_name  r2 contenant l’adresse de début du buffer. Ensuite nous effectuons le calcul de l’adresse de l’entrée suivante car le type du fichier que nous venons d’afficher se trouve au caractère précèdent l’entrée suivante (ouf !!). En fonction de ce type nous affichons le message correspondant. (ici je me suis contenté de n’afficher que les types fichiers et répertoires). Et nous terminons en bouclant.

Remarquez que rien n’indique la fin des entrées stockées dans la structure. Il nous faut donc conserver le nombre d’octets lus dans le registre r6 et à chaque entrée traitée il faut ajouter sa longueur au registre r7 . Ceci permet de comparer les 2 registres et d’arrêter la boucle quand tous les octets sont traités.

Exercice :  compléter le programme avec les autres types de fichiers.

                Afficher toutes les informations de chaque entrée (inode, offset, longueur).

                Éliminer de l’affichage les 2 répertoires Unix . et .. (au fait savez-vous à quoi ils correspondent ?)

Chapitre 9: taille et informations d'un fichier

Avant de lire un fichier et de stocker son contenu dans le buffer, il serait intéressant de connaitre sa taille avant de le lire et d’agir en conséquence (par exemple : afficher un message d’erreur).

Dans la documentation des call system, nous trouvons l’appel newfstat code 6c (les autres fonctions comme stat et fstat ne sont pas implémentées) qui retourne toute une série d’information sur un fichier passé en paramètre. En fait c’est un pointeur qui est retourné dans le registre r0 et ce pointeur donne l’adresse d’une structure qui contient soit les informations soit des adresses vers d’autres données.

Il est possible d’accéder à chaque donnée de la structure en ajoutant son déplacement (offset) au pointeur de la structure  comme ldr r1,[r0,#8]. Mais il est plus parlant d’y accéder par ldr r1,[r0,#Taille] et il nous faut donc décrire la structure en assembleur. L’assembleur as n’est pas très bien conçu (avis personnel !) pour décrire les structures mais il offre quand même un mécanisme pour le faire. Il permet d’associer des noms de zones à un déplacement en indiquant la longueur en octets de chacune d’elles. L’instruction .struct effectue cette association sans réserver de zones en mémoire. Pour l’utilisation il suffira d’ajouter au pointeur de début de structure, le nom adéquat.

Voyons sur l’exemple des infos d’un fichier. La documentation des call system indique que la structure s'appelle stat et donne sa description en langage c

struct stat {

        unsigned int   st_dev;

        unsigned int   st_ino;

        unsigned int   st_mode;

        unsigned int   st_nlink;

        unsigned int   st_uid;

        unsigned int   st_gid;

        unsigned int   st_rdev;

        long           st_size;

        unsigned long  st_atime;

        unsigned long  st_mtime;

        unsigned long  st_ctime;

        unsigned int   st_blksize;

        unsigned int   st_blocks;

        unsigned int   st_flags;

        unsigned int   st_gen;

};

Et bien, nous allons reprendre cette description et la traduire pour l’assembleur en préfixant les zones par Stat et en considérant que chacune occupe 4 octets :

/* structure de type   stat  : infos fichier  */

    .struct  0

Stat_dev_t:                  /* ID of device containing file */

    .struct Stat_dev_t + 4

Stat_ino_t:                   /* inode */

    .struct Stat_ino_t + 4

Stat_mode_t:             /* File type and mode */

    .struct Stat_mode_t + 4          

Stat_nlink_t:                /* Number of hard links */

    .struct Stat_nlink_t + 4            

Stat_uid_t:                    /* User ID of owner */

    .struct Stat_uid_t + 4

Stat_gid_t:                      /* Group ID of owner */

    .struct Stat_gid_t + 4                

Stat_rdev_t:                  /* Device ID (if special file) */

    .struct Stat_rdev_t + 4

Stat_size_t:                   /* Total size, in bytes */

    .struct Stat_size_t + 4              

Stat_blksize_t:             /* Block size for filesystem I/O */

    .struct Stat_blksize_t + 4        

Stat_blkcnt_t:              /* Number of 512B blocks allocated */

    .struct Stat_blkcnt_t + 4         

Stat_Fin:            

Puis nous écrivons le programme qui va ouvrir le fichier, puis appeler la fonction NEWSTAT et nous allons afficher la mémoire correspondant au pointeur de la structure. Puis nous allons afficher la zone Stat_size_t qui devrait contenir la taille.

Voici le source du programme :

Voici le résultat sur le fichier fic1.

Mais il y a un petit problème : la taille affichée ne correspond pas à celle donnée par ls –l. Il y a un décalage entre les infos de la structure et le résultat. Donc je pars à la recherche sur Internet des différentes descriptions de Stats.h en C et je trouve que certaines données sont des short (2octets) et non pas des integer (4 octets) et d’autres comme la taille sont des longs (8 octets) et je complète aussi avec les zones concernant les dates du fichier . Donc je rectifie la structure comme suit :

/* structure de type   stat  : infos fichier  */

    .struct  0

Stat_dev_t:                  /* ID of device containing file */

    .struct Stat_dev_t + 4

Stat_ino_t:                   /* inode */

    .struct Stat_ino_t + 2

Stat_mode_t:             /* File type and mode */

    .struct Stat_mode_t + 2          

Stat_nlink_t:                /* Number of hard links */

    .struct Stat_nlink_t + 2            

Stat_uid_t:                    /* User ID of owner */

    .struct Stat_uid_t + 2

Stat_gid_t:                      /* Group ID of owner */

    .struct Stat_gid_t + 2                

Stat_rdev_t:                  /* Device ID (if special file) */

    .struct Stat_rdev_t + 2

Stat_size_deb:           /* la taille est sur 8 octets si gros fichiers */

                 .struct Stat_size_deb + 4

Stat_size_t:                   /* Total size, in bytes */

    .struct Stat_size_t + 4              

Stat_blksize_t:             /* Block size for filesystem I/O */

    .struct Stat_blksize_t + 4        

Stat_blkcnt_t:              /* Number of 512B blocks allocated */

    .struct Stat_blkcnt_t + 4         

Stat_atime:                   /*   date et heure fichier */

    .struct Stat_atime + 8    

Stat_mtime:                 /*   date et heure modif fichier */

    .struct Stat_atime + 8

Stat_ctime:                   /*   date et heure creation fichier */

    .struct Stat_atime + 8              

Stat_Fin:            

Cette fois ci le programme est correct et je trouve bien la longueur du fichier en hexa dans le registre r1. En conclusion, il nous faudra par la suite, vérifier par des tests la validité des structures.

Remarque : j’ai décrit la structure utilisée en reprenant les noms anglais, mais il est possible de franciser ces noms.

Exercice :  Afficher dans la console d’autres informations du fichier.

                  Et sans doute plus difficile, la date de création du fichier étant codée sur 8 octets, écrire une routine qui l’affiche sous la forme JJ/MM/AAAA  HHh MMm SSs.

Chapitre 8 :Lecture et écriture de fichiers.

Pour ces premiers pas, nous allons nous contenter d’ouvrir un fichier de type texte, et de lire son contenu dans un buffer que nous afficherons avec notre sous routine de vidage mémoire. Tout d’abord créez avec nano un petit fichier avec un texte quelconque et sauvez le avec le nom fic1.txt.

Dans la documentation des appels système linux, nous trouvons le code 5 pour la fonction OPEN à laquelle il faut fournir le nom du fichier (avec éventuellement son chemin) et des paramètres pour indiquer si nous voulons ouvrir le fichier en mode lecture seule (O_RDONLY) en mode écriture( O_WRONLY) ou lecture écriture (O_RDWR).

Lien vers le source du programme.

Nous allons créer ces valeurs comme constantes et ici je les ai mis en commentaires pour vous donner les codes correspondants car elles sont contenues maintenant dans mon fichier des constantes.

Dans la section .data nous ajoutons les libellés d’erreur et une zone où nous mettons le nom du fichier (fic1.txt) que nous allons lire (En commentaire j’ai mis aussi le nom du fichier complet pour tester ce cas). Dans la section .bss, nous déclarons un buffer avec une taille suffisante.

Dans la partie code, nous renseignons les 3 registres avec l’adresse du nom du fichier, le mode d’ouverture avant d’appeler la fonction d’ouverture. En retour nous testons le registre r0 pour voir s’il y a une erreur (vous pouvez le tester en mettant un nom de fichier inexistant dans le répertoire). S’il n’y a pas d’erreur le registre contient un identifiant le File Descriptor (FD) qui va remplacer dans les autres appels les codes des consoles standards (vous savez 0, 1 ou 2)

Car en effet pour la lecture des données, nous utilisons le même appel système (READ) que pour la saisie au clavier, seul le code du registre r0 est changé (et le buffer doit être plus grand !!).

Ensuite nous affichons le contenu du buffer pour vérification et nous terminons le programme par la fermeture du fichier (appel système CLOSE). Le FD du fichier a du être conservé dans le registre r8 pour éviter sa perte dans le registre r0 utilisé lors de l’affichage précédent.

Voici le résultat :

Nous voyons que le registre r0 indique le nombre d’octets lus (en hexa) que le buffer contient bien les caractères avec des lignes se terminant par des caractères 0A. Le registre r8 contient la valeur 3 donc le FD du programme. Ce nombre doit correspondre à un indice dans une table gérée par le système. Il faudrait voir s’il est possible d’accéder à cette table pour extraire des infos intéressantes sur le fichier : c’est à creuser.

Nous avons lu un fichier au format texte et donc comment lire d’autres formats ?: et bien pareil car rien en assembleur ne différencie les types de fichiers, c’est à vous programmeur à définir ce que représente le fichier et à le traiter de la bonne façon. D’autre part nous avons déclarer un buffer de 512 caractères ce qui est minuscule si nous voulons traiter de gros fichiers. Soit nous déclarons des buffers de millions d’octets (dans la limite de la mémoire disponible) soit nous écrivons une boucle qui lit le fichier par tranche de 512 octets (ou autres valeurs) et nous traitons chaque tranche avant de lire l’autre.

Voyons maintenant l’écriture dans un fichier : c’est tout bête car nous allons utiliser le même appel système que notre sous routine d’affichage (WRITE) mais en l’appliquant sur un File Descriptor que le système va créer.

Pour compliquer un petit peu la programmation je vous propose un programme qui va ouvrir un lire un fichier de commande dont le nom sera passé dans la ligne de commande. Chaque ligne de ce fichier de la forme nom=valeur sera décodée et utilisée pour écrire une série de chiffre dans un fichier de sortie.

Voici le contenu du fichier de commande  et qui s’appelle commande.txt  (Original non !!) :

Ligne=10

Fichier=resultat.txt

Il est crée avec un éditeur de texte comme nano.

Analysons le programme (lien vers le source du programme) :

Dans la section .data après les habituels libellés d’erreur nous trouvons la déclaration de tables de pointeurs qui vont nous permettre de décrire les mots clés autorisés dans le fichier commande. Tout d’abord nous trouvons une table de pointeurs vers les libellés des mots clé : pour le premier nous trouvons le libellé fichier à l’adresse cle1 que nous stockons dans le premier poste. Ensuite nous trouvons la table du type de chaque mot clé : alpha ou numérique et enfin nous trouvons une table des valeurs de chaque mot clé. Cette dernière sera alimentée après le décodage du fichier commande. Si le type d’un mot clé est numérique, le poste contiendra sa valeur après conversion sinon le poste contiendra l’adresse de la chaine correspondante.

Ensuite nous trouvons un pointeur du début du tas. Un tas est une grande zone de mémoire qui va nous servir à stocker les chaines de caractères les unes à la suite des autres. Bien sûr chaque chaine sera identifié par un pointeur vers son début. Pour stocker une chaine dans le tas il nous faut donc toujours connaitre l’adresse de la première position libre sur le tas.

Dans la section .bss, nous déclarons les buffers et zones de travail et bien sûr le tas. Ici il est de petite taille mais pour des programmes qui devront manipuler des quantités de chaines il pourra être beaucoup plus important. (Cela me fait penser que dans ce programme, je ne vérifie pas si le stockage d’une chaine dépasse la taille du tas !! à prévoir).

Dans la partie code, nous commençons par récupérer le nombre de paramètres de la ligne de commande et nous vérifions s’il y a en au moins 2 (rappel le 1^er est toujours le nom du programme lancé). Nous récupérons l’adresse du 2^ième que nous mettons dans r5 et nous nous en servons pour ouvrir le fichier.et récupérer le FD pour lire le contenu et enfin pour le fermer car nous avons les données lues dans la zone buffer.

Ensuite nous appelons une routine qui va analyser les lignes lues. Nous allons balayer les caractères un à un pour trouver un mot clé (dont la fin est signalée par le signe =) en éliminant les blancs éventuels et en terminant si nous trouvons les caractères 0 ou 0A hexa. Dés que nous avons trouvé le signe égal, nous continuons l’analyse mais en mettant dans le registre r5, l’adresse de la zone valeur pour y stockée les caractères jusqu’à trouver une fin de ligne ou un 0 binaire.  Si la ligne est complète cad si nous avons les zones motcle et valeurs renseignes nous appelons la sous routine TraitMotCle.

Dans celle-ci, nous allons chercher si le mot cle trouvé est un mot clé autorisé en balayant la table des mot clé et en effectuant une comparaison des 2 chaines. Si nous avons égalité , nous cherchons le type correspondant grâce à l’indice  trouvé. Si le type est numérique nous devons convertir la chaine stockée dans valeur en une valeur numérique qui sera stockée dans la table des valeurs dans le poste correspondant à l’indice trouvée. Si le type est alphanumérique, c’est un peu plus compliqué. En effet il faut stocker la chaine dans le tas.Pour cela nous récupérons l’adresse du début du tas puis nous recopions la chaine contenue à l’adresse valeur sur le tas puis nous mettons à jour le pointeur de tas avec la prochaine position libre.

Donc au final, nous avons analysé chaque ligne du fichier commande et stocké dans une table chaque valeur associé au mot clé. Vous pouvez voir qu’il est possible d’ajouter d’autres mots clé sans modifier la programmation. Il est possible aussi d’améliorer l’analyse pour signaler qu’ un mot clé indispensable n’a pas été trouvé (ou plutôt prévoir une valeur par défaut).

 Maintenant nous revenons dans le programme principal et nous savons que dans le 1^er poste de la table des valeurs nous avons l’adresse du nom du fichier de sortie. Nous créons ce fichier par l’appel de la fonction CREATE (code 8)  avec  un masque spécial ficmask1: .octa 0644. Ce code permet d’avoir les droits corrects pour l’utilisation du fichier (voir la documentation Unix sur les droits des fichiers ). Cette fonction retourne dans r0 un FD que nous utiliserons pour écrire dans le fichier par l’appel système WRITE comme nous l’avons utilisé pour la routine d’affichage.

Mais auparavant, il nous faut créer les données à écrire. Pour cela nous récupérons la valeur du paramètre ligne (ici égal à 10) et par une boucle nous générons autant de lignes qui contient le N° de boucle ? Évidement, il nous faut convertir le compteur de boucle en caractères ascii et en décimal signé (la même fonction que nous avons utilisé pour afficher un registre). Nous ajoutons à chaque ligne le caractère de fin de ligne 0A hexa et nous stockons le tout dans la zone buffer. Pour l’écriture, il nous faut connaitre le nombre de caractères total et donc nous le comptons dans le registre r2.

En fin nous fermons le fichier par l’appel système CLOSE. Vous pouvez regarder le résultat en affichant par more le contenu du fichier resultat.txt. Vous pouvez modifier le fichier commande pour changer le nombre de lignes à écrire ou le nom du fichier de sortie sans avoir à modifier le programme.

Cet exemple est à conserver pour des développements futurs car nous avons vu quelques points qui vont se répéter lors de l’écriture de programmes.

Exercice : ajouter dans le fichier commande le mot clé titre=ETAT NO 1  et modifier le programme pour faire apparaitre ce titre en haut du fichier résultat.

             Tester le programme en éclatant une ligne sur plusieurs lignes par exemple :

Ligne

=

10

Corriger le programme pour qu’il fonctionne correctement.

Ajouter dans le fichier des commandes des commentaires commençant par * : ceux-ci ne doivent pas perturber les résultats.