Modifications

=== L'interpréteur MicroPython ===

=== L'interpréteur MicroPython ===

{{traduction}}

{{traduction}}

The Micro Python implementation is a complete rewrite of Python specifically designed to be run on a microcontroller with minimal flash storage and minimal RAM. When design decisions were made, the first priority was to minimise RAM usage, then minimise code size, and, finally, to execute quickly.  Some of the important features of the implementation are listed below.

Micro Python est une ré-écriture complète d'un interpréteur Python spécialement, ré-écriture conduite pour fonctionner sur des systèmes MicroControleur ayant une mémoire RAM et Flash limitée. Lorsque des décisions de conceptions se présentait, la première priorité était celles permettant de minimiser l'utilisation de la RAM, puis minimisation de la taille du code, et finalement celle permettant d'augmenter la vitesse d'exécution.

* Follows the Python 3.3 grammar and language semantics. This means that Micro Python produces equivalent byte code (up to optimisations) to the official CPython version 3.3.

* Size of space-optimised binary compiled to Thumb v2 machine code: around 60KiB. This includes the parser, compiler, runtime and garbage collector, but excludes all other code, including file system support and libraries related to the specific microcontroller. This size will increase if more Python libraries are added.

* Suivre la grammaire de Python 3.3 ainsi que la sémantique du langage. Cela signifie que Micro Python produit un byte code équivalent (jusqu'à l'optimisation) à va version 3.3 CPython officiel.

* Size of all code, including FAT support, SD card, USB serial, USB mass storage, USB HID, Bluetooth, LCD, servo, timer: about 110KiB.

* La taille du binaire optimisé (en code machine Thumb v2) fait '''environ 60Kb'''.<br />Cela inclus le parser, compilateur, environnement d'exécution et garbage collector MAIS exclus tous les autre code comme le système de fichier et bibliothèques spécifiques au microcontroleur. Cette taille augmente si vous ajoutez plus de bibliothèques.

* Minimum RAM required to compile and execute "print('hello world')": around 4KiB.

* La taille de tout le code, incluant le support FAT, carte SD, USB série, périphérique de stockage USB, USB HID, Bluetooth, LCD, servo, timer fait '''environ 110 Kb'''.

* Memory is managed using a fast, non-precise, mark-sweep garbage collector. This eliminates reference counting overhead in flash code size and object RAM size. A fast CPU and small amount of RAM means that a complete garbage collection takes under 4ms. The garbage collector RAM overhead is 2 bits per 32 bytes = 1KiB for 128KiB usable RAM.

* La taille minimale de la RAM requise pour compiler et exécuter "print('hello world')" est d''''environ 4 Kb'''.

* Size of int object: 4 bytes, stored on the stack or directly in a tuple/list/dictionary.

* La mémoire est gérée en utilisant un garbage collector (''ramasse miette') rapide, non-precise, mark-sweep. Cela élimine la surcharge de code provoquée par une implémentation en "reference counting" (compteur de référence) en mémoire Flash. La taille des objet en RAM diminue par la même occasion. Avec un CPU rapide et une petite quantité de RAM, la processus de collection (garbage collection) prend moins de 4ms. La surcharge de RAM du garbage collector est de 2 bits par 32 bytes soit 1 Kb pour 128Kb de mémoire RAM utilisable.

* Size of other objects: 32 bytes, plus extra for, eg, elements of a list.

* Taille des objets int (entier): 4 bytes, stocké sur la stack (''pile'') ou directement dans un tuple/list/dictionnaire.

* Limit on number of objects: none, so long as there is enough RAM.

* Taille des autres objets: 32 bytes, plus extra pour, par exemple, les éléments d'une liste.

* The grammar is encoded in a compact table using EBNF which is interpreted on-the-fly when parsing.

* Limite sur le nombre d'objets: aucune, pour autant qu'il y a assez de RAM.

* RAM is minimised during compilation by performing 3 separate passes over the same data structure.

* La grammaire est encodée dans une table compacte en  utilisant EBNF qui permet de faire une interprétation à la volée pendant la phase de parsin.

* There are 4 types of code emitters, selectable per function by function decorators: (compressed) byte code, native code, native code with native types, and inline assembler. Byte code runs on a virtual machine, similar to CPython. Native code has each byte code unrolled to its equivalent machine code, and supports the full Python language. It takes about 2-3 times more RAM, but runs about 2-3 times faster than byte code. The third type, native code with native types, has byte code unrolled to machine code and further assumes that integers are smaller than 31 bits, so that it can use a single machine instruction for integer and pointer operations. You can think of it as "Python syntax, C semantics". For tight loops that perform arithmetic and bit manipulation (common on a microcontroller), it can perform close to the speed of the equivalent C program. The fourth code emitter is inline assembler.  It uses the Python grammar, but is interpreted as a list of machine code instructions. Inline assembler can be called from normal Python code with integer and pointer arguments.

* La RAM est minimisée durant la compilation en effectuant 3 passes séparée sur les mêmes structures de données.

* Il y a 4 types de générateur de code (''code emitters''), sélectionnable à l'aide de décorateur de fonction Python:

** byte code (compressé),  

** code natif avec type natif,  

** code natif avec support du langage python,

** Assembleur inline assembler.

** Le byte code est exécuté sur une machine virtuelle, similaire à CPython.

** Le code natif ou chaque byte code est décompressé en sont équivalent 'code machine'  et supporte pleinement le langage Python. Cela consomme 2 à 3 fois plus de RAM mais s'exécute aussi 2 à 3 fois plus vite que du byte code.  

** Le code natif avec type natif vois sont byte code décomposé en code machine et suppose que les entiers font moins de de 31 bits (ce qui permet d'utiliser des instructions machines simples pour des opérations sur les entiers et les pointeurs). Vous pouvez penser à cela comme "syntaxe Python, sémantique C". Pour les boucles effectuant des opération arithmétiques et manipulations de bit, l'exécution est presque aussi rapide qu'un programme en C.

** L'emission d'assembleur inline utilise la grammaire Python mais interprète une liste d'instruction code machine. L'assembleur Inline peut être appelé depuis un code Python normal avec des entiers et pointeurs comme arguments.

* Python exceptions are handled using a variant of setjmp/longjmp.  This reduces the amount of flash and RAM needed to implement exceptions.

* Python exceptions are handled using a variant of setjmp/longjmp.  This reduces the amount of flash and RAM needed to implement exceptions.

* A function (byte code, native or inline assembler) can be called on an interrupt long as it does not allocate heap memory (since it can be called while a garbage collection is taking place).  In practice this is not a big restriction, as you can do a lot of things using only memory on the stack.  For example, you can make loops with while/for, do integer arithmetic and bitwise operations (but no bignums), call other functions and access and overwrite elements of collections like bytearrays (but not create new ones).

* A function (byte code, native or inline assembler) can be called on an interrupt long as it does not allocate heap memory (since it can be called while a garbage collection is taking place).  In practice this is not a big restriction, as you can do a lot of things using only memory on the stack.  For example, you can make loops with while/for, do integer arithmetic and bitwise operations (but no bignums), call other functions and access and overwrite elements of collections like bytearrays (but not create new ones).