# Introduction

Ce didacticiel est destiné aux utilisateurs sachant écrire un peu de code de la Simple Virtual Machine.

Dans ce didacticiel, vous allez découvrir l'environnement de base d'exécution du code de la machine virtuelle.

Le temps de lecture de ce didacticiel est estimé à 15 minutes.

# Mise en place

Pour commencer, créez le canevas de l'application dans le fichier exécutable noyau.svm en utilisant ce code :

    #!/usr/bin/env svm
    DESCRIPTION
    Kernel exploration
    END
    LOG
    DEBUG "Kernel"
    PROCESS "application"
    	CODE "main" INLINE
    		:debug BREAK
    	END
    END

# Composants d'un noyau

Lancez l'application en mode débugueur, puis ouvrez la fenêtre des noyaux depuis le menu principal, ainsi que la fenêtre du noyau présent dans la liste :

Kernel
Kernel list
PROCESS application - Kernel main (D)
Kernel main - P application
State: D, transmit_interruption
Processor
Memory

Comme cela est mis en évidence dans la fenêtre noyau du débugueur, un noyau est constitué d'un processeur et d'une mémoire liés entre eux.

Telle une machine physique, cette association entre processeur et mémoire est indivisible car nécessaire pour l'exécution du code machine.

# Contexte atomique d'exécution de code

Modifiez le code pour ajouter quelques instructions :

    #!/usr/bin/env svm
    DESCRIPTION
    Kernel exploration
    END
    LOG
    DEBUG "Kernel"
    PROCESS "application"
    	CODE "main" INLINE
    		:debug BREAK
    		:memory INT/i, INT/s
    		0 -> &s
    		1 -> &i
    	:label loop
    		:shift @&i &s
    		:shift &i
    		:goto loop :when @&i IN &0*10
    		[46m[ [46m] -> i
    	END
    END

Puis exécutez l'application pas à pas dans le débugueur tout en observant les fenêtres noyau, processeur et mémoire. Vous pourrez noter que l'ensemble des valeurs contenues dans le processeur et la mémoire est modifié par les instructions en fonction de ce qu'elles réalisent.

C'est d'ailleurs ainsi que se réalise un calcul dans la machine :

1. le noyau est initialisé avec les valeurs d'entrée du calcul,
2. les instructions transforment le noyau pour réaliser les étapes du calcul,
3. une fois le calcul terminé, le noyau contient les valeurs de sortie du calcul.

Comme les instructions savent implicitement dans quel noyau elles sont exécutées et puisent en celui-ci les valeurs dont elles ont besoin, le noyau joue pour les instructions un rôle de contexte minimal d'exécution de code machine.

# Etat et options

## Etat

Un noyau indique s'il est en cours d'exécution grâce à un état pouvant indiquer s'il est actuellement en train d'exécuter du code, mis en pause ou terminé.

Cet état est présenté dans la fenêtre noyau du débugueur par une lettre majuscule :

- R ou D indiquent que le noyau exécute du code,
- S indique que le noyau est mis en pause,
- Z ou I indiquent que le noyau a terminé son exécution.

## Options

De plus, trois options peuvent modifier le comportement d'un noyau :

1. transmit_interruption : cette option permet à une autre entité de traiter le cas où ce noyau se termine par une interruption du processeur,
2. last_return_is_shutdown : cette option permet d'exécuter une fonction en isolation dans un noyau sans modifier son code,
3. protected_mode : cette option permet une exécution plus stricte du code, lorsque ce code provient d'une source non fiable.

- Un noyau est constitué d'un processeur et une mémoire liés entre eux.
- Les instructions s'exécutent dans un noyau qui sert de contexte atomique d'exécution.
- Un calcul dans un noyau se réalise en modifiant le noyau.
- Un noyau possède un état qui reflète son activité.

# Conclusion

Vous venez de voir qu'un noyau constitue la brique de base de l'architecture de la machine virtuelle.

Toute la première série de didacticiels a eu pour vocation de décrire ce qui peut se passer au sein d'un noyau.

A partir de maintenant, l'architecture générale de la machine virtuelle va vous être révélée pour pouvoir orchestrer à un niveau macroscopique l'exécution du code de l'application.