Un ordinateur ordinaire avec un systèmes Linux est censé fonctionner avec moins de 1024 processus en cours d'exécution. Dans les algorithmes évoqués, le nombre d'exécutions parallèles de procédure doit pouvoir atteindre 100 000. Pour obtenir cette capacité, on va programmer notre propre gestion de processus, une gestion spécifique à notre langage de programmation et qui correspondra à une sérialisation des processus. Chaque processus mémorise un environnement, et se subdivise en une série de portions d'exécution, qui sont misent en série mais en balayant tous les procéssus en cours d'exécution, de telle sorte que ces processus semblent s'exécuter parallèlement.
On prend comme premier exemple le générateur de nombre premier par le crible d'Eratosthène. On utilise un sac `E` vide et un index `i"="2`. Puis on répète indéfiniment ce qui suit :
Si `i` n'appartient pas à `E` alors c'est qu'il est premier. On l'écrit sur la sortie, `i"≫"sf"Out"`, on le met dans `E`, `i"≫"E`, et on lance un nouveau processus parallèle qui ajoute dans `E` tous les multiples de `i`. On incrémente `i`. On attend que tous les processus émettent au delà.
Si `i` appartient à `E` alors c'est qu'il n'est pas premier. On incrémente `i`, et on attend que tous les processus émettent au delà.
`E={}`
`i = 2`
`sf"loop"{`
`(i"∈"E){i=i+1}`
`(i"∉"E){`
`i"≫"sf"Out"`
`i"≫"E`
`Q(i)&_(n<i)`
`}`
`}``color(#660000)sf"function" Q(i){`
`sf"var" k=i`
`sf"var" n=i`
`sf"loop"{`
`n=n+k`
`n"≫"E`
`}`
`}`
L'instruction `(i"∈"E){i=i+1}` signifie : Si `i` appartient à `E` alors incrémentez `i`. L'instruction `Q(i)&_(n<i)` signifie : Lancez la procédure `Q(i)` en arrière plan et devant progresser dans son exécution à chaque fois que la variable `n` locale à la procédure satisfait `n"<"i`.
---- 29 juin 2024 ----