Lazi

Logiciel compute

Présentation

Le logiciel compute lit un fichier XML de définitions et un fichier XML de calcul(s) à exécuter, exécute les calculs et retourne les résultats sous forme d'un fichier XML. Le progamme "lazi" sert à encapsuler l'utilisation des divers programmes et donc en temps normal "compute" n'est pas lancé directement et le résultat des calculs est une page HTML présenté par un navigateur.

Bases mathématiques

Pour optimiser les calculs, ce qui les rend possibles sur un ordinateur ordinaire, il est nécessaire que compute calcul sur les expressions Lazi plus des notations.

Les notations utilisées par compute :

  • Fonction : Notation pour représenter une fonction à une variable, l'équivalent du $F des sources avec une seule variable ordinaire.
  • Définition des noms : l'équivalent du "$Def" des sources.
  • Représentation des mots
  • Représentation des formules

Il est toutefois possible de faire calculer compute sur des formules sans notation. Pour cela il faut ajouter l'option shortcut="0" en attribut de la commande de calcul. Dans ce cas compute traduit les notations avant de les calculer.

Autres fonctionnalités

Profilage

Un paramètre d'une commande de calcul peut déclencher le profilage. Le profilage voit les constantes globales comme des fonctions et Lazi estime l'arité (valeur indiquée dans le résultat) de chaque définition. Le profilage donne deux durée pour chaque nom :

  • Le temps interne, correspondant au temps passé à calculer le constante globale et ses arguments.
  • Le temps externe, correspondant au temps passé à calculer après avoir calculer les arguments de la fonction correspondante.

Le profilage et le traçage prennent un temps conséquent, les valeurs données n'ont donc qu'un intérêt de comparaisons relatives.

Les shortcuts

Certaines fonctions gourmandes en tant de calcul (comme wordEqual) ne sont pas calculées en utilisant la définition Lazi mais par un calcul interne à compute. Il est possible de désactiver cette fonctionnalité en utilisant l'option shortcut="1" (ou même 0). Un shortcut correspond toujours à une constante globale, si les arguments ne sont pas dans un format pratique (par exemple si les deux arguments de wordEqual ne sont pas des représentations de mot littéraux) alors les arguments sont calculés et ce calcul est gardé que le shortcut puisse être appliqué ou non.

Si le shortcut ne peut être appliqué (si les arguments ne sont pas dans un format acceptable pour opérer le shortcut) alors le calcul normal est réalisé.

Traçage

La fonction "trace", définie par $Def trace = $F opt,label,test,testComp,print,value → value n'a pas d'intérêt du point de vue mathématique, mais est exécutée par un shortcut ayant un effet de bord (externe au calcul). Cette fonction permet d'afficher une valeur ou bien la pile d'appel Lazi, de plus un teste permet de décider si la trace est effectuée. La documentation de cette fonction se trouve à sa définition Lazi.

La notion de "pile d'appels" Lazi est une notion artificielle crée uniquement pour le traçage. À chaque fois qu'une formule correspondant à une constante globale et ses arguments est calculée, la formule est ajoutée dans la pile d'appels. La pile d'appels est réduite quand un sous-calcul (par exemple pour le premier argument de "if") est fini.

Un programme Lazi incluant n'importe où l'utilisation (non compris la définition) de "trace" est plus lent à être exécuter car alors la pile d'appels est mise à jour.

Calculs groupés et testes

compute permet de prendre une suite de formules à calculer. Pour chaque commande de calcul il est possible de spécifier des options (comme le niveau de shortcut) ou encore la comparaison à une valeur attendu (les calculs sont arrêtés si le teste échoue).

Entrées / Sorties

Les entrées

Les options du programme

En italique les options obligatoires. Les formules, que ce soient en entrée ou en sortie, sont au format xml.

  • -h, --help : L'aide
  • -d DEFINITIONS_FILE : Chemin du fichier xml des définitions.
  • -c COMMAND_FILE : Chemin du fichier xml des commandes.
  • -o FILE : Chemin du ficher de sortie. La sortie se fait sur STDOUT si l'option est absente.

Le fichier des définitions des constantes globales

Ce fichier est en général produit par le logiciel "translate" à partir des sources Lazi. Il est au format XML et contient les valeurs de tous les noms définis. L'entête doit être:

<?xml version="1.0" encoding="UTF-8"?>
<definitions>

suivit d'une suite de définitions et terminé par le tag fermant

Une définition a le format :

<definition name="ABC">formule-xml</definition>

où "ABC" est le nom à définir et "formule-xml" la valeur du nom sous forme d'une formule XML.

Le fichier de commandes

Présentation

Habituellement les interpréteurs interprètent "main" et il n'y a pas de fichier de commandes. Cela aurait pu être aussi le cas pour Lazi et dans ce cas le fichier de définitions aurait été suffisant. Pour simuler le système habituel on peut fournir un fichier de commande simple demandant à calculer "main". Mais on peut aussi demander à calculer une ou plusieurs expressions quelconques et passer pour chaque calcul des options tel que:

  • le niveau de shortcut
  • activation du traçage
  • activation du profilage
  • activation de la fonction de teste (pour comparer le résultat produit et arrêter s'il n'est pas bon).

Le fichier de commandes est donc très utile pour lancer une batterie de testes.

Format

Il doit commencer par

<?xml version="1.0" encoding="UTF-8"?>
<commands>

suit une liste de commandes (tag <compute>) ou titres (tag <title>)terminée par </commands>

Le tag

=====

Il permet de séparer les commandes quand elles sont nombreuses (comme des testes de validation) et redémarre le compteur du numéro de commande à 1.

Le format est

Texte du titre

= Format du tag =

= Arguments =

Tous les arguments sont optionels.

  • profile : valeurs "true" ou "false" (défaut) : active le profilage
  • shortcuts-level : Le niveau d'optimisation de calcul à utiliser. Les calculs sont très ralentis si les optimisations ne sont pas utilisées.
    • 0 : aucune optimisation
    • 1 : Le calcul des fonctions ($F x -> ...) est optimisé
    • 2 (défaut) : En plus, des calculs de certaines fonctions (comme wordEqual x y) sont optimisés.
  • max-depth (entier): limite la profondeur des formules affichées en sortie, par défaut pas de limite.
  • compute-args (bool): calcul les arguments dans l'expression résultat (true/false, défaut à false).
  • max-callstack (entier) : Arrête le calcul quand la limite de la taille de la pile d'appel Lazi est atteinte, la pile est alors affichée dans la trace. Utile quand il y a une boucle infinie.
  • max-callstack-trace (entier) : limite la trace de la pile aux n premiers éléments.

= Contenu =

  • La formule à calculée, sous forme xml.
  • Optionnel : Si on veut que le résultat soit comparé à une expression attendue, on ajoute dans le tag autour de la formule xml devant être le résultat du calcul.
  • Optionnel : On peut ajouter un commentaire par le tag ...

La sortie

Présentation

Le fichier de sortie fournit les résultats des calculs exécutés suivant le fichier des commandes. C'est un fichier xml qui liste les résultats.

Format

Il commence par

<?xml version="1.0" encoding="UTF-8"?>
<reports>

, contient une liste de tags et se termine par .

Format d'un tag

= Argument =

number=n où n est la place dans la liste.

= Contenu =

  • La commande exécutée, dans le même format que le fichier de commande (tag "compute" etc).
  • Un tag fournissant le résultat. Il a pour arguments:
    • done : "true" ou "false", indique si un calcul a pu être fait.
    • passed : "true" ou "false", argument présent si la commande est un teste (tag "check"), indique si le teste a réussit.

  • **** et pour contenu :
    • La formule xml résultat : si ce n'est pas un calcul de teste ou si le teste a échoué.

  • Si le profiling est actif: un tag contenant les données à ce sujet.
  • Si il y a des traces: un tag contenant une liste de tags ayant un attribut "label" et une formule en contenu.

Les règles du calculs

Soit e l'expression à calculer, une seule règle est appliquée qui est la première applicable dans l'ordre du tableau ci-dessous. Ici "$Args" représente une liste (éventuellement vide) d'argument(s) supplémentaire(s). Par exemple la formule "f x y z t" peut se représenter "f x $Args" où dans ce cas $Args représente les arguments y,z et t. La liste d'argument supplémentaire est la même avant et après calcul.

niveau shortcut e résultat Commentaire
--------------- ---------------------------------------- --------------------------- ----------------------------------------------------------

|2

|(expression shortcut de niveau 2) $Args
|(calcul du shortcut) $Args
| |
|1
|($F v -> body) x $Args
|body2 $Args
|où body2 le remplacement de la variable v par x dans body
|
|0
|if 1b x y $Args
|x $Args
| |
|0
|if 0b x y $Args
|y $Args
| |
|0
|if x y z $Args
|if x' y z $Args
|où x' est le résultat du calcul de x
|
|0
|distribute x y z $Args
|(x z) (y z) $Args
| |
|0
|n
|x
|si n est le nom d'une constante globale et x sa valeur.
|

Systèmes internes

Hash table des noms

Pour optimiser les calculs les noms (mots clés, variables, noms définis) sont stockés dans des hash-tables. De plus pour chaque nom d'un certain type il n'existe qu'un seul objet. Ainsi la constante globale "wordEqual" peut être utilisée dans plusieurs formules il n'existera qu'un seul objet pour ce nom. De ce fait la comparaison de nom revient à comparer les pointeurs. On obtient donc une optimisation en temps de calcul et en espace mémoire.

= Type de formule = classe =

Le système des classes C++ est abondamment utilisé pour représenter les différents types de formules (Apply, Function etc). La classe racine est Formula.

Les "Sharer"

Un type de formule ne représente ni le langage Lazi-0 (Apply et WordKey) ni des notations, ce sont les "sharers". Ces types dérivent tous de FormulaShell (voir dossier "formula/share" dans le code source). Ces classes encapsulent une formule pour changer le comportement. Cela sert à partager le calcul de la sous-formule, mais aussi à changer le comportement du remplacement de variable. Avec ce système nous arrivons à diminuer au minimum la recherche des variables et à éliminer totalement la duplication interne des calculs.

@todo