Opale: noyau multithreadé pour ti68k

C'est quoi ?

Voici la première beta publique d'Opale, un noyau embarqué qui a donc pour vocation de permettre à des programmes d'adopter une structure multithreadée.

Comment ça marche ?

Opale est pour l'instant distribuée sous forme de lib statique. Elle propose des fonctions qui permettent d'initialiser le noyau, de lancer le noyau, de gérer les tâches et les outils de synchronisation et de communication.

Commençons par l'ordonnancement.
C'est l'algorithme qui permet de choisir entre toutes les tâches existante, celle qui va être exécutée. Opale propose deux méthodes: par priorités strictes, ou par priorités tournantes.

Priorités strictes: telle que distribuée, la bibliothèque permet d'avoir 64 tâches, chacune possédant un niveau de priorité unique (de 0, le plus haut niveau, à 63). Ces niveaux sont exculsifs, ainsi il est impossible que deux tâches aient le même niveau.
Lorsque l'ordonnanceur doit élire la tâche à exécuter, il choisira toujours la tâche de plus haute priorité prête à être exécutée.

Priorités tournantes:les priorités sont regroupées en 8 niveaux de 8 priorités. Les priorités 0 à 7 sont au niveau 0, les priorités 8 à 15 au niveau 1, etc. L'ordonnanceur va d'abord déterminer le niveau de plus haute priorité contenant des tâches prêtes, puis exécuter à tour de rôle les tâches qu'il contient. Lorsqu'un niveau est vide, on passe au suivant, etc.

Tâche inactive:
La tâche de plus faible priorité est allouée par le noyau et reçoit automatiquement la priorité la plus faible (63).

Suspension d'une tâche:
Il es possible de mettre en sommeil une tâche pour un nombre donné de ticks. Un tick est l'intervale de temps séparant deux déclenchements de l'auto-int 5, donc environ 18Hz.

Préemption:
Si un évênement quelconque rend prête à l'exécution une tâche plus prioritaire que la tâche courante , celle-ci est automatiquement mise en suspend, et la tâche plus prioritaire est exécutée.

Sémaphores et Mailbox:
Ces deux objets permettent de synchroniser et de faire communiquer les tâche. Un sémaphore est un compteur qui peut être pris ou relâché par une tâche. Prendre le compteur le décrémente, et le relâcher l'incrémente. Une tentative de prise d'un compteur qui est à 0 provoque l'endormissement de la tâche jusqu'à ce que le sémaphore soit relùaché par une autre tâche et que la tâche soit celle de plus haute priorité en attente de ce sémaphore.
Il en va de même pour les mailbox, sauf qu'un message (un pointeur typiquement) remplace le compteur. Un seul message peut être posté à la fois, mais plusieurs tâches peuvent être mises en attente de ce message. La tâche de plus haute priorité en attente recevra le message lorsu'il sera posté.

Divers:

première beta publique, complètement unsafe (à éviter sur une vrai TI a priori)
tout compris, envron 1400 octets
deux exemples inclus: l'un qui mesure l'occupation CPU (appuyez sur une touche)
l'autre qui exécute pas mal de tâches pour le fun (mais n'appuyez pas sur une touche)

il est évident que toutes les règles de codages de programmes multithreadés s'appliquent en utilisant Opale, par exemple ça serait une mauvaise idée d'allouer de la mémoire dynamiquement dans une tâche qui peut se faire préempter, ou d'appeler des fonctions d'AMS non réentrante, etc.

Testé uniquement sous VTI, et encore une fois c'est probablement très bugué a priori
à suivre



API (en anglais, et j'espère avoir été un peu clair.... c'estsurment pas complètement de l'anglais en fait):
http://mapage.noos.fr/cmolon/opale/

Pack:
http://mapage.noos.fr/cmolon/opale/Opale.zip

(j'espère qu'il y a tout ... et que j'ai pas fait trop de fautes )


edit: ti screen d'une app utilisant 5 tâches, une mailbox et un sémaphore:



edit2: le code du prog en question:

Source

C'est qui qui a fait ça ?

Euh... moi ?

genre tu programmes

ba non Opale est une vaste fumisterie, un poisson d'avril quoi ^^

Non sans rire ?

>>23:58 @Ximoon - Posté : 31-03-2005

Et en plus il s'est craqué de 2 minutes

lol, est-ce qu'il y en a seulement un qui a téléchargé le zip ?

bah oui

faut pas croire les poissons hein ^^
Opale existe vraiment

arf je me suis fait avoir par le poisson qui disait que c'était un poisson

Pour une fois que je suis un minimum productif vous êtes durs quand même

bah faut dire que poster 2 minutes avant le premier avril un topic avec ce titre...

Oui, certes...

Y'a pas les sources ?

Pas encore, éventuellement sur demande. Les sources seront probablement disponibles plus tard sous forme de tuto ou d'article équivalent. Faut surtout que je les documente généreusement aussi

voici la bêta 2

+ ajout des queues de messages (en gros, comme des boîtes à lettre mais qui peuvent contenir plus d'un message et les stocker en attendant qu'ils soient lus)
+ l'int5 présente à l'initialisation d'Opale n'est plus détruite mais appelée après l'interruption du noyau
+ changement: il n'est plus conseillé (plus possible quoi ) de changer le masque des interruptions pendant une tâche
+ quelques modifications mineures ...

API (en anglais, et j'espère avoir été un peu clair.... c'est surment pas complètement de l'anglais en fait):
http://mapage.noos.fr/cmolon/opale/

Pack:
http://mapage.noos.fr/cmolon/opale/Opale-beta2-21-04-2005.zip

Je n'ai pas regardé en détail l'API, mais j'ai une petite question de moindre importance : il est possible de demander de ne pas rappeler l'ancienne int5 après le déroulement du noyau quand on l'installe ?

Apparemment non. C'est pas grave, on peut le faire à la main... Mais ça aurait été pratique que ce soit paramétrable.

Sinon, tu pourrais éventuellement stopper le kernel quand on appuie sur DIAMOND + ON (par exemple, ou une autre combinaison de touches).
Enfin, dans une application propre, on ne devrait pas avoir à faire cette combinaison, mais je pense que ça pourrait être pratique d'avoir cette sécurité.

Non, mais rien n'empêche bien sûr de détourner l'interruption avant d'appeler la fonction d'initialisation du noyau. Si nécessaire je rajouterai des primitives de configuration supplémentaire, mais je n'y avais pas pensé avant maintenant.

(cross pour le post précédent bien sûr)

pour le hotkey, j'aimerais rester aussi général que possible, et ne pas surcharger le système par des appeles customs de ce genre. Mais une fois encore rien n'empêche de le faire à la main (un appel à op_KernelStop() dans une ISR c'est vite fait). De plus je crois que PreOs peut rattraper les dégats (pas essayé les hot escapes encore par contre).

(en fait je ne veux pas introduire à ce niveau d'interface utilisateur, si limitée soit-elle, ça n'est pas le but)

OK, tu as raison, ta lib sera plus légère.
C'est toujours difficile quand on développe une lib de trouver les limites de ce qu'on fournit...

J'ai commencé à mettre à jour la doc: les sources C sont fournies ici et partiellement commentées, suivront les sources assembleur.
Si vous voyez des bugs en lisant les sources, merci de les reporter (oui on peut rêver ).

Je cherche une license pour le distribuer, j'aurais bien mis du GPL mais ça me dérange si ça ne permet pas d'utiliser la lib dans un projet close-source... Y'a pas un truc ouvert qui permet la réutilisation du code pour modification mais soit moins contraignant quand à l'utilisation de la lib elle-même ?

http://mapage.noos.fr/cmolon/opale/

Ben, la LGPL est déjà moins contraignante...

ah... fais tout de même gaffe si tu veux rester compatible GPL...

J'ai pas l'impression qu'il y ait beaucoup de licenses qui soient compatibles GPL et qui puissent se linker avec du closed-source...

moi aussi... c'est ça le pb

Bah oui, la LGPL est pas mal pour ça.

Bon après avoir lu la license LGPL ça m'a l'air pas mal, vais probablement pencher de ce côté.