Les efforts de Ingo Molnar ont été momentanément mis en attente avec la suppression du Big Kernel Lock apparu pour (de mémoire) le 2.6.27. Tout ça pour arriver (enfin) à maîtriser la latence.
Aujourd'hui, où en est-on exactement ? A part que la plupart des handlers se contruisent avec la problématique de latence en tête, il reste des approches contradictoires, ou plus exactement "nombrilistes" : si l'on veut que "son" driver soit temps réel à latence la plus faible alors il faut que tous les autres drivers aient une latence sous interruption maîtrisée (donc souvent en 2 parties) mais que l'on écrive son propre driver en monobloc... Rassurons-nous, la différence entre les deux reste très faible.
A voir en pratique...
Prochaine étape : tickless kernel sur OpneMoko et Pandora.
lundi 24 novembre 2008
jeudi 28 août 2008
FreeRunner
Ca y est, je l'ai ! un téléphone dont tout l'ensemble logiciel est en très forte majorité Open Source. Seule exception, la pile GSM, intégralement contenue dans une puce pour éviter les soucis liés au protocole (on ne va tout de même pas envoyer un faux IMSI pour faire facturer le voisin...).
Pour le reste, résolution intéressante, réactivité convenable, pas mal du tout le QTopia.
L'aspect technique ? Un kernel 2.6.22.x patché, donc pas de tickless kernel. C'est certainement un des éléments qui expliquent une autonomie faiblarde. Une saisie, basé sur un tandem clavier / dictionnaire prédictif, divise la communauté. Bref, le travail a besoin d'encore un peu de finition.
Pour le reste, résolution intéressante, réactivité convenable, pas mal du tout le QTopia.
L'aspect technique ? Un kernel 2.6.22.x patché, donc pas de tickless kernel. C'est certainement un des éléments qui expliquent une autonomie faiblarde. Une saisie, basé sur un tandem clavier / dictionnaire prédictif, divise la communauté. Bref, le travail a besoin d'encore un peu de finition.
mercredi 25 juin 2008
Première Matinale Red Hat
Hier (mardi 24/6) matin, j'ai eu l'opportunité d'être convié à une Matinale Red Hat, la première du nom en fait. Le but : présenter toutes les nouveautés de l'entreprise au Fedora rouge dans le domaine de la virtualisation, ainsi que 2 invités de marque, Intel pour montrer la participation du fondeur aux technologies de virtualisation, et un cas concret de mise en oeuvre de virtualisation, présenté par des membres de l'équipe de DSI de Pages Jaunes.
Concernant la virtualisation, à part un engagement de Red Hat avec Xen jusqu'en 2014 et des développements poussant aujourd'hui des technologies du kernel 'Vanilla', au premier chef kvm, l'accent est surtout mis sur la carence actuelle des logiciels libres de virtualisation, que j'avais identifiée avec mon collègue D. Hannequin dans le Livre Blanc publié par LINAGORA sur le sujet : les outils d'administration de parc virtuel. D'excellentes nouvelles donc.
La fin de leur présentation signalait aussi une annonce nommér MRG : Messaging Realtime Grid, basé sur Linux, série 2.6.24. La mise en avant d'un produit annoncé temps réel dur basé sur un kernel "vanilla"...
J'avais ouvert ce blog en espérant merttre en évidence que cela était en effet possible, mais le résidu de BKL (Big Kernel Locks) dans le kernel, et l'évaluation de A. Morton à environ 10 ans de travail pour s'en débarrasser totalement m'avait un peu ramené à la dure réalité : not yet.
Et toujours pas d'ailleurs, en réalité, mais qu'un des plus gros industriels impliqués dans le noyau s'y engage, c'est une excellente nouvelle. On tient les paris... Pour 2009 ?
Concernant la virtualisation, à part un engagement de Red Hat avec Xen jusqu'en 2014 et des développements poussant aujourd'hui des technologies du kernel 'Vanilla', au premier chef kvm, l'accent est surtout mis sur la carence actuelle des logiciels libres de virtualisation, que j'avais identifiée avec mon collègue D. Hannequin dans le Livre Blanc publié par LINAGORA sur le sujet : les outils d'administration de parc virtuel. D'excellentes nouvelles donc.
La fin de leur présentation signalait aussi une annonce nommér MRG : Messaging Realtime Grid, basé sur Linux, série 2.6.24. La mise en avant d'un produit annoncé temps réel dur basé sur un kernel "vanilla"...
J'avais ouvert ce blog en espérant merttre en évidence que cela était en effet possible, mais le résidu de BKL (Big Kernel Locks) dans le kernel, et l'évaluation de A. Morton à environ 10 ans de travail pour s'en débarrasser totalement m'avait un peu ramené à la dure réalité : not yet.
Et toujours pas d'ailleurs, en réalité, mais qu'un des plus gros industriels impliqués dans le noyau s'y engage, c'est une excellente nouvelle. On tient les paris... Pour 2009 ?
lundi 5 mai 2008
Latences...
Tout d'abord la référence : la programmation temps-réel a ses normes : POSIX 4d9, devenu POSIX 1003.1b-1993 puis POSIX 1003.1i-1995. Totu cela indique comment coder une application utilisateur qui se comporte d'une certaine manière et quelles sont les obligations et/ou bonnes partiques d'un OS en terme de réponse.
Du point de vue d'une application, le temps est continu, la seule chose à prendre en compte est que le temps entre deux "gettimeofday" est foncièrement indécidable. L'important donc pour un code en mode utilisateur, c'est essentiellement de pouvoir réquisitionner le processeur dans des temps bornés (réaction à sollicitation), ou en temps prévu (interval timer).
Or cette réquisition va se faire moyennant un certain délai, entièrement du ressort de l'OS : le temps d'interrompre une tâche (user ou kernel) en cours, le temps de sélectionner la tâche à éxécuter, le temps de reprendre.
Concernant la reprise, le temps peut être considéré comme à peu près constant, il s'agit d'un temps de commutation de contexte très peu dépendant du processus à réactiver (la seule dépendance, liée à la présence ou non du code à réactiver dans le cache, n'est pas maitrisable). Sur ce point on peut donc trouver un temps majorant assez simplement.
L'interruption d'un processus utilisateur est de la même veine. Dans le cas particulier, donc, d'un processus utilisateur à interrompre, la qualité temps réel de la réquisition du processeur par le système pau profit d'un autre processus est complètement liée à la qualité temps réel de la sélection du processus à sélectionner (le scheduler).
Cas un peu plus complexe mais très fréquent : la sollicitation arrive sous forme d'une interruption. En rajoutant l'hypothèse que le processus en cours est un processus utilisateur. C'est un cas qui peut se ramener rapidement au précédent, puisque la commutation de tâches dans un système à temps partagé se fait en programmant un générateur d'interruptions (timer). On a donc "simplement" rajouté le temps de traitement particulier de l'interruption considérée - et ôté la durée du handler du timer.
Les *vrais cas difficiles c'est quand on interrompt un bout de code kernel.
Du point de vue d'une application, le temps est continu, la seule chose à prendre en compte est que le temps entre deux "gettimeofday" est foncièrement indécidable. L'important donc pour un code en mode utilisateur, c'est essentiellement de pouvoir réquisitionner le processeur dans des temps bornés (réaction à sollicitation), ou en temps prévu (interval timer).
Or cette réquisition va se faire moyennant un certain délai, entièrement du ressort de l'OS : le temps d'interrompre une tâche (user ou kernel) en cours, le temps de sélectionner la tâche à éxécuter, le temps de reprendre.
Concernant la reprise, le temps peut être considéré comme à peu près constant, il s'agit d'un temps de commutation de contexte très peu dépendant du processus à réactiver (la seule dépendance, liée à la présence ou non du code à réactiver dans le cache, n'est pas maitrisable). Sur ce point on peut donc trouver un temps majorant assez simplement.
L'interruption d'un processus utilisateur est de la même veine. Dans le cas particulier, donc, d'un processus utilisateur à interrompre, la qualité temps réel de la réquisition du processeur par le système pau profit d'un autre processus est complètement liée à la qualité temps réel de la sélection du processus à sélectionner (le scheduler).
Cas un peu plus complexe mais très fréquent : la sollicitation arrive sous forme d'une interruption. En rajoutant l'hypothèse que le processus en cours est un processus utilisateur. C'est un cas qui peut se ramener rapidement au précédent, puisque la commutation de tâches dans un système à temps partagé se fait en programmant un générateur d'interruptions (timer). On a donc "simplement" rajouté le temps de traitement particulier de l'interruption considérée - et ôté la durée du handler du timer.
Les *vrais cas difficiles c'est quand on interrompt un bout de code kernel.
lundi 21 avril 2008
O temps suspends ton vol...
Je viens de voir à l'occasion de la sortie du kernel Linux 2.6.25 l'existence de l'outil latencytop. De quoi au moins outiller mes propos, pour les latences que l'outil saura mesurer.
Après parcours de la liste des innovations de la 2.6.25, il semble que l'effervescence se soit calmée pour la partie scheduler. Tant mieux, il y a tant à dire pour la 2.6.24 !
Les latences possibles que j'imagine au niveau kernel (les freins à une latence faible) ?
- tout d'abord le matériel. Il est illusoire de demander à un ARM2 à 8MHz d'obtenir une latence identique à un Core2 duo dont la fréquence interne est facilement 250 fois supérieure ! De même les accès RAM et les débits RAM ont profité d'une amélioration spectaculaire ces 10 dernières années et les systèmes auxquels on demande les meilleures perfs RT ne sont pas les machines dernier cri...
- ensuite le codage interne du kernel. Blocage sous Mutex, Ordonnaceur trop long, interruptions désactivées trop longtemps sont les principales causes d'accroissement de latence. Un handler d'IT mal écrit peut décider de la latence complète du système. Ce n'est pas propre à Linux, un vendeur d'OS temps réel l'a appris à ses dépends sur son propre driver disque dur !
- Enfin l'utilisation du système. une machine qui croule régulièrement sous la charge, dimensionnée pour accepter juste la charge, ne sera peut-être pas en mesure de tenir systématiquement uen latence faible. On ne peut exiger d'une machine prévue pour bosser 10 secondes à 110% de ses capacités de prétendre avoir un comportement temps réel pendant cette surcharge sans risquer de voir certaines piles déborder (au mieux), certaines latences diverger (au pire).
Donc on commencera à parler de temps réel sous les conditions suivantes :
- Les erreurs de codage manifestes sont exclues,
- L'erreur de sous-dimensionnement pour de longs intervalles est écartée,
- On demande au matériel des latences qu'il a une chance de tenir.
Après parcours de la liste des innovations de la 2.6.25, il semble que l'effervescence se soit calmée pour la partie scheduler. Tant mieux, il y a tant à dire pour la 2.6.24 !
Les latences possibles que j'imagine au niveau kernel (les freins à une latence faible) ?
- tout d'abord le matériel. Il est illusoire de demander à un ARM2 à 8MHz d'obtenir une latence identique à un Core2 duo dont la fréquence interne est facilement 250 fois supérieure ! De même les accès RAM et les débits RAM ont profité d'une amélioration spectaculaire ces 10 dernières années et les systèmes auxquels on demande les meilleures perfs RT ne sont pas les machines dernier cri...
- ensuite le codage interne du kernel. Blocage sous Mutex, Ordonnaceur trop long, interruptions désactivées trop longtemps sont les principales causes d'accroissement de latence. Un handler d'IT mal écrit peut décider de la latence complète du système. Ce n'est pas propre à Linux, un vendeur d'OS temps réel l'a appris à ses dépends sur son propre driver disque dur !
- Enfin l'utilisation du système. une machine qui croule régulièrement sous la charge, dimensionnée pour accepter juste la charge, ne sera peut-être pas en mesure de tenir systématiquement uen latence faible. On ne peut exiger d'une machine prévue pour bosser 10 secondes à 110% de ses capacités de prétendre avoir un comportement temps réel pendant cette surcharge sans risquer de voir certaines piles déborder (au mieux), certaines latences diverger (au pire).
Donc on commencera à parler de temps réel sous les conditions suivantes :
- Les erreurs de codage manifestes sont exclues,
- L'erreur de sous-dimensionnement pour de longs intervalles est écartée,
- On demande au matériel des latences qu'il a une chance de tenir.
lundi 10 mars 2008
Les temps réels...
Temps réel dur, temps réel mou, de quoi parle-t-on ?
On parle de temps réel lorsque la programmation peut se faire par échéance. Par exemple "j'ai besoin d'exécuter tel exécutable à tel moment". Dans le cas d'un système POSIX standard sans aucun complément temps réel, on peut presque atteindre, sur une machine peu chargée, avec une précision convenable, des délais à la seconde près... Peut-être à peu près suffisant pour un GPS piéton, mais guère mieux...
Par la suite, les extensions orientées temps réel sont arrivées, et se sont normalisées. Il s'agit essentiellement de proposer des interfaces à peu près communes pour accéder, sur les ensembles hard+soft le permettant, de meilleures précisions. A discrétion du vendeur...
Le débat central se situe alors sur la certitude du respect des échéances et du retard auquel on peut s'attendre. Prenez une application comme la video, une surcharge à un moment peut vous faire perdre une trame, on réussit en général à en reconstituer une bonne partie sans dommage. Au pire on vous fait rater une image. Prenons le cas d'un ABS : au pire on vous fait rater... un virage !!!
La question centrale donc : quelle précision suis-je sûr d'atteindre dans tous les pire cas (sauf faute de sous-dimensionnement violent de ma capacité...), quelle précision puis-je atteindre dans "juste" 90% des cas ?
Pendant longtemps, seuls les systèmes propriétaires permettaient une telle garantie. Et encore, sous certaines réserves. En effet, si un OS vous permet de désactiver les interruptions et que vous décidez sous interruptions désactivées de réordonner les particules de l'Univers, vous allez faire exploses vos échéances... Pour y parer certains OS interdisent l'accès direct aux handlers d'IT, au détriment de la performance (ex : Solaris jusque version 6). Un fournisseur d'OS avait même commis cette boulette dans un de ses propres drivers de disque...
Aujourd'hui, Linux arrive dans ce domaine, fort d'une réputation sulfureuse de "non temps réel", acquis tout au long de son histoire. La question est autant polémique que violemment pointue.
Ce qui gêne potentiellement, ce sont les intervalles de temps où un système ne peut être interrompu. Un énorme travail a été fait pour diminuer cette granularité du kernel Linux sous forme de patches à la branche 2.4, reporté en 2.5 et intégré au 2.6 (branche actuelle). Après cela, il reste à vérifier que la sélection du processus à exécuter (scheduling) prend un temps déterminé.
C'est chose faite avec le Completely Fair Scheduler du kernel 2.6.24. Reste à déterminer la latence maximale et les conditions aux limites de ce kernel. C'est ce travail que je me propose de faire et de documenter.
On parle de temps réel lorsque la programmation peut se faire par échéance. Par exemple "j'ai besoin d'exécuter tel exécutable à tel moment". Dans le cas d'un système POSIX standard sans aucun complément temps réel, on peut presque atteindre, sur une machine peu chargée, avec une précision convenable, des délais à la seconde près... Peut-être à peu près suffisant pour un GPS piéton, mais guère mieux...
Par la suite, les extensions orientées temps réel sont arrivées, et se sont normalisées. Il s'agit essentiellement de proposer des interfaces à peu près communes pour accéder, sur les ensembles hard+soft le permettant, de meilleures précisions. A discrétion du vendeur...
Le débat central se situe alors sur la certitude du respect des échéances et du retard auquel on peut s'attendre. Prenez une application comme la video, une surcharge à un moment peut vous faire perdre une trame, on réussit en général à en reconstituer une bonne partie sans dommage. Au pire on vous fait rater une image. Prenons le cas d'un ABS : au pire on vous fait rater... un virage !!!
La question centrale donc : quelle précision suis-je sûr d'atteindre dans tous les pire cas (sauf faute de sous-dimensionnement violent de ma capacité...), quelle précision puis-je atteindre dans "juste" 90% des cas ?
Pendant longtemps, seuls les systèmes propriétaires permettaient une telle garantie. Et encore, sous certaines réserves. En effet, si un OS vous permet de désactiver les interruptions et que vous décidez sous interruptions désactivées de réordonner les particules de l'Univers, vous allez faire exploses vos échéances... Pour y parer certains OS interdisent l'accès direct aux handlers d'IT, au détriment de la performance (ex : Solaris jusque version 6). Un fournisseur d'OS avait même commis cette boulette dans un de ses propres drivers de disque...
Aujourd'hui, Linux arrive dans ce domaine, fort d'une réputation sulfureuse de "non temps réel", acquis tout au long de son histoire. La question est autant polémique que violemment pointue.
Ce qui gêne potentiellement, ce sont les intervalles de temps où un système ne peut être interrompu. Un énorme travail a été fait pour diminuer cette granularité du kernel Linux sous forme de patches à la branche 2.4, reporté en 2.5 et intégré au 2.6 (branche actuelle). Après cela, il reste à vérifier que la sélection du processus à exécuter (scheduling) prend un temps déterminé.
C'est chose faite avec le Completely Fair Scheduler du kernel 2.6.24. Reste à déterminer la latence maximale et les conditions aux limites de ce kernel. C'est ce travail que je me propose de faire et de documenter.
mardi 4 mars 2008
Départ...
Ce blog a pour seul but d'exprimer toutes les idées, plus ou moins farfelues, qui me passent par la tête au sujet du temps réel. Sa réalisation s'inspire d'une discussion enflammée à la fin du cycle de conférences embarqué à Solutions Linux 2008.
Fondamentalement, j'ai tiré de cette longue discussion quelques éléments simples : tout d'abord, la notion de temps réel dur et de temps réel non-dur est un peu incomplète, l'interprétation usuelle étant que le temps réel dur est "borné". Aucun système informatique ne peut gérer des éléments en nombre non borné, et hors de toute erreur manifeste de codage (boucle infinie), un temps de réponse est toujours borné, la seule contrainte à appréhender est si le pire des cas (la borne supérieure) est acceptable, et si le cas à 99% convient.
Concrètement, Linux est-il temps réel dur ? Avec un scheduler en O(1) et des points de préemption placés dans le kernel, moyennant une expertise du code que je vais m'empresser de faire, je dirais oui. Mais pas temps réel dur à 0,1ms, ni temps réel dur à 1ms. L'ordre de grandeur ressemble plus à 10ms, ce qui peut être rédhibitoire pour certains usages (même pour contrôler un ABS on est limite). Et encore, moyennant un réglage particulier du kernel et un processeur suffisamment puissant.
Donc la bonne question est : "Mon OS peut-il garantir une échéance à x millisecondes sur mon hard dans 100% des cas ? dans 99% des cas ?". Le boulot d'ingénieur c'est de savoir conclure si oui ou non la combinaison hard/soft permet de remplir le contrat voulu.
La difficulté, non pas pour l'aspect temps réel mais beaucou plus pour l'embarqué, c'est d'accepter de surdimensionner son matériel pour atteindre le 100%. Ce surdimensionnement peut très bien être complètement inacceptable d'ailleurs (contraintes de coûts par exemple). Un hard+OS qui vous fait 1ms à 99,9% des cas et 25ms sur le 0,1% restant, c'est frustrant de l'acheter pour du 25ms...
Fondamentalement, j'ai tiré de cette longue discussion quelques éléments simples : tout d'abord, la notion de temps réel dur et de temps réel non-dur est un peu incomplète, l'interprétation usuelle étant que le temps réel dur est "borné". Aucun système informatique ne peut gérer des éléments en nombre non borné, et hors de toute erreur manifeste de codage (boucle infinie), un temps de réponse est toujours borné, la seule contrainte à appréhender est si le pire des cas (la borne supérieure) est acceptable, et si le cas à 99% convient.
Concrètement, Linux est-il temps réel dur ? Avec un scheduler en O(1) et des points de préemption placés dans le kernel, moyennant une expertise du code que je vais m'empresser de faire, je dirais oui. Mais pas temps réel dur à 0,1ms, ni temps réel dur à 1ms. L'ordre de grandeur ressemble plus à 10ms, ce qui peut être rédhibitoire pour certains usages (même pour contrôler un ABS on est limite). Et encore, moyennant un réglage particulier du kernel et un processeur suffisamment puissant.
Donc la bonne question est : "Mon OS peut-il garantir une échéance à x millisecondes sur mon hard dans 100% des cas ? dans 99% des cas ?". Le boulot d'ingénieur c'est de savoir conclure si oui ou non la combinaison hard/soft permet de remplir le contrat voulu.
La difficulté, non pas pour l'aspect temps réel mais beaucou plus pour l'embarqué, c'est d'accepter de surdimensionner son matériel pour atteindre le 100%. Ce surdimensionnement peut très bien être complètement inacceptable d'ailleurs (contraintes de coûts par exemple). Un hard+OS qui vous fait 1ms à 99,9% des cas et 25ms sur le 0,1% restant, c'est frustrant de l'acheter pour du 25ms...
Inscription à :
Articles (Atom)