Programmation modulaire

Lorsque l'on commence à créer des programmes de taille conséquente, il devient nécessaire d'organiser le code de manière propre. Pour cela on peut répartir les fonctions en groupes de fonctions qui s'occuppent de plus ou moins la même tâche, on appelle cela un module.

I - Préfixes de modules

Habituellement, quand on lance une fonction, celle-ci s'exécute entièrement, puis la ligne d'après, etc. Par exemple, dans ce programme :

function f(x) do

    for (i, 0, 5) do

        print(x)

    end

end

f(1)

f(2)

on aura un affichage ressemblant à ceci :

1

1

1

1

1

2

2

2

2

2

Voyons une méthode pour exécuter ces deux fonctions en même temps. A partir de maintenant, nous parlerons de processus. Un processus est un programme dans lequel toutes les instructions s'exécutent les unes après les autres. Ainsi, d'habitude, nous n'utilisons qu'un seul processus : le processus principal. Mais nous pouvons aussi avoir plusieurs processus qui s'exécutent en même temps. Pour créer un nouveau processus, il faut d'abord avoir une fonction créée à l'aide de function. C'est cette fonction qui sera exécutée dans un nouveau processus. Pour la lancer en parallèle, il suffit d'écrire :

parallel f(arguments)

Pour illustrer ce propos, le programme de tout à l'heure, mais avec la fonction f lancée en parallèle :

function f(x) do

    for (i, 0, 5) do

        print(x)

    end

end

parallel f(1)

parallel f(2)

II - Gérer le retour de fonctions exécutées en parallèle

Depuis le début, les fonctions que nous avons lancées en parallèle ne renvoyaient rien. Mais on peut parfaitement faire des processus qui renvoient une valeur.

Mais comment ça marche ?

En réalité, quand vous lancez une fonction avec le mot-clé parallel, ce mot-clé vous renvoie une valeur de type Promise (une promesse).

Cette promesse est une sorte d'identifiant pour le processus qui vous l'a envoyée. Tant que le processus n'a pas terminé, cette promesse aura la valeur (et le type) d'une promesse, comme le montre la capture d'écran ci-dessus. Mais une fois que le processus qui vous a envoyé la promesse termine, alors la promesse (et toutes les copies que vous en aurez faites) se transformeront en la valeur de retour du processus. Exemple avec ce programme :

function f(x) do

    for (i, 0, x) do

        x += x

    end

    return (x)

end

p = parallel f(10)

print(p)

l = [p, p, p, p, p]

print(l)

while (type(p) == "Promise") do

    pass

end

# le processus est maintenant fini

print(p)

print(l)

Décortiquons-le un peu.

Tout d'abord, je définis une fonction qui calcule un nombre en fonction de x, son paramètre.

Ensuite, j'appelle cette fonctions avec x=10, et je récupère le retour de parallel dans la variable p.

J'affiche p, puis je crée une liste contenant 5 fois p et je l'affiche.

Enfin, j'attends que le processus p se termine (j'attends que la promesse se transforme), puis j'affiche p et la liste l.

Ce qui se passe est très simple : Avant la fin du processus, on ne manipule que des promesses, donc on n'affiche que des promesses, puis une fois le processus fini, toutes les promesses se sont transformées en la valeur renvoyée par le processus. Voici d'ailleurs la sortie de ce programme :

III - L'attente passive

Dans le programme du dessus, pour attendre que le processus finisse, j'utilise une boucle while qui ne fait rien. Ce comportement peut être dérangeant puisque cela consomme de la puissance du processeur pour pas grand chose. De plus lorsque l'on programme avec des processus, il peut être utile d'avoir des processus qui attendent des événements, sans pour autant pomper toute la puissance du processeur. Par exemple, si je veux faire un processus qui attend que quelqu'un appuie sur une touche, je n'ai pas envie que ça ralentisse mes autres processus qui eux, calculent des choses utiles.

C'est pour cela que Neon permet l'attente passive au sein d'un processus. Cette attente passive est réalisée à l'aide du mot-clé await(condition). Tant que la condition n'est pas vérifiée, le processus est mis en pause, et uniquement les autres processus sont exécutés. L'interpréteur va seulement aller vérifier la condition de temps en temps. Une fois la condition vérifiée, le processus mis en pause repart comme si de rien n'était.

Ainsi, grâce au mot-clé await, on peut écrire une fonction qui attend la fin d'un processus, mais plus efficacement :

function join(p) do

    await(type(p) != "Promise)

end

Tant que p a le type promise, le processus qui a appelé join est mis en pause, et il repart après.

IV - Blocs d'instructions atomiques

Quand on écrit un programme utilisant plusieurs processus, on est parfois amené à également utiliser des variables globales que chaque processus peut lire et modifier. Mais parfois, cela peut causer des problèmes. Regardons le programme ci-dessous :

function f() do

    if (type(nombre) == "Number") then

        return (nombre + 1)

    end

end

function g() do

    for (i, 0, 10) do

        nombre = "coucou"

    end

end

nombre = 15

parallel f()

parallel g()

Dans ce cas, au moment où on va exécuter f, il peut se passer deux choses. Ou alors, après avoir testé la valeur de la variable nombre, cette valeur n'aura pas changée, auquel cas tout va bien.

Mais il peut se passer une autre chose. Entre le moment où f teste la valeur de nombre et renvoie nombre+1, il se peut que la fonction g modifie cette valeur, auquel cas, "coucou"+1 n'a pas de sens, et le programme aura une erreur.

Il existe donc un mécanisme qui permet de garantir qu'un ensemble d'instructions est exécuté d'une traite, sans qu'aucun autre processus n'ait le droit de faire quoi que ce soit.

Ce mécanisme, c'est le bloc d'instructions atomiques.

La syntaxe se présente comme ceci :

atomic

    instructions1

    instruction2

    ...

end

Pour conclure, on pourrait écrire tout le corps de la fonction f dans un bloc atomic, et on serait certain que la fonction g ne peut pas modifier la variable nombre entre temps.

V - Comment ça marche ?

Vous le savez, Neon a pour vocation de pouvoir être utilisé partout, sur n'importe quelle machine. Or, vous le savez aussi, beaucoup de machines n'ont pas la possibilité d'exécuter matériellement plusieurs programmes à la fois. C'est pour cela qu'en réalité, les différents processus que l'on peut créer ne s'exécutent pas réellement en même temps. L'interpréteur Neon réalise ce qu'on appelle de l'entrelacement.

Il a une liste de processus, et il exécute un peu d'instructions de chaque processus avant de passer au processus suivant. Cette manière de faire est compliquée à gérer, mais rend l'interpréteur souverain de tout ce qu'il fait. Ainsi, l'interpréteur peut choisir combien d'instructions il veut exécuter sur chaque processus avant de passer au suivant.

Et à travers une fonction, vous pouvez choisir le nombre d'instructions exécutées sur chaque processus avant de passer au suivant. Cette fonction s'appelle setAtomicTime, et vous permet de spécifier un nombre d'instructions atomiques.