Bonsoir
Que de nostalgie... DJNZ 0x10... toute mon adolescence ! mais à
l'époque j'étais plutôt sur le demo-making que sur le micro-kernel.
Ton mini-scheduler de tâches est simple et efficace. Bravo.
Une coroutine est (aujourd'hui) souvent conçue pour un langage de
programmation haut-niveau qui tourne déjà sur une système multi-
threads. Sa particularité vient de la méthode "yield" qui permet de
rendre la main "provisoirement"
https://en.wikipedia.org/wiki/Coroutine
En partant de ton scheduler de tâches, je verrai bien simplement un
équivalent de "yield" après l'affichage d'un caractère (pour ton
exemple de print) qui consisterait en la séquence:
- écrire (ps + x octets) dans la stack associée au processus
- jump vers la logique de bascule de tâche qui tu factorises dans une
méthode
En calculant le "x octets" correspondant au décalage requis pour que le
retour du sp arrive juste après le jump.
Ton gestionnaire d'interruption réutilisera alors la méthode factorisée
de changement de tâches.
Pour faire "joli" et éviter du copier/coller, il faudrait que une macro
"yield" pour ce changement de contexte programmatique et une autre
macro pour générer la pile des processus et son entrée dans la table...
mais d'un autre côté tu n'es plus très loin d'écrire le code nécessaire
à la création un processus à la volée dans un espace mémoire réservé à
cet effet.
Ensuite viendra peut-être la nécessité d'un gestionnaire de mémoire
heap avec malloc. Pour un jeu, probablement pas besoin de free ou de
suppression de processus. Mais si tu veux te simplifier la vie, même si
c'est beaucoup moins fun, il suffirait juste de coder au-dessus de
CP/M, je pense que pour le paiement de license, il y a prescription.
C'était l'épique époque des peeks et des pokes !
--
Yves Martin
On Wed, 2021-12-08 at 14:53 +0100, Frédéric wrote:
> Hello,
>
> Quelqu'un aurait-il un bon tutoriel (de préférence en français mais pas
> obligatoirement) sur le concept des coroutines ?
>
> Je me suis remis à la programmation assembleur Z80 en faisant un reboot
> du jeu d'aventures que j'avais développé (et commercialisé) au début
> des
> années 90, sur Amstrad CPC.
>
> Dans ce jeu, il y a un timing serré à respecter sur une frame. J'ai
> déjà
> implémenté une FSM pour passer d'une routine à une autre, ne pouvant
> pas
> tout faire en même temps dans une même frame : refresh écran, update
> musique, lecture clavier, gestion curseur, affichage texte, moteur du
> jeu lui-même... Mais certaines de ces taches, comme l'affichage texte,
> ne
> peuvent pas se faire en une seule fois, il faut que je divise encore,
> par
> exemple en affichant caractère par caractère.
>
> Du coup, je pense que la fonction 'print' se prêterait bien aux
> coroutines : à la fin de chaque caractère affiché, je rend la main à la
> boucle principale, et je continue où j'en étais à l'appel suivant.
>
> Surtout que j'avais aussi écrit un micro-noyau multitaches préemptif
> pour
> Z80 : c'est une bonne base de départ, puisqu'il y a tout ce qu'il faut
> pour la sauvegarde de contexte et la commutation de tache :
>
> https://rasmlive.amstrad.info/edit/XkiiPiGGBasyypKTc
>
> Mais j'aimerais avoir une bonne idée du fonctionnement des coroutines
> pour
> implémenter ça proprement (même si c'est juste partiellement dans un
> premier temps, car du fait de la FSM, je n'aurai pas nécessairement
> besoin
> de coroutines concurrentes)...
>
> Merci d'avance.
>
