Quelles sont les raisons pour lesquelles une pile Java / Linux ne parvient pas à être «en temps réel»?

J'ai souvent entendu des développeurs mentionner que Java ne peut pas " faire en temps réel ", ce qui signifie qu'une application Java fonctionnant sous Linux ne peut pas répondre aux exigences d'un système déterministe en temps réel, comme quelque chose s'exécutant sur RIOT-OS, etc.

J'essaie de comprendre pourquoi . Mon SWAG me dit que cela est probablement dû en grande partie au Garbage Collector de Java, qui peut s'exécuter à tout moment et interrompre totalement le système. Et bien qu'il existe des soi-disant «GCs sans pause», je ne crois pas nécessairement leur publicité, et je n'ai pas non plus 80 000 $ par instance JVM à débourser pour un projet de loisir!

Je lisais également cet article sur l'exécution de logiciels de drones sous Linux . Dans cet article, l'auteur décrit un scénario où Linux a failli faire planter son drone dans sa voiture:

J'ai appris une dure leçon après avoir choisi de faire la boucle de contrôle de bas niveau (PID) sur le Pi - en essayant d'être intelligent, j'ai décidé de mettre une écriture de journal au milieu de la boucle pour le débogage - le quad a d'abord bien volé mais Linux a ensuite décidé de prendre 2 secondes pour écrire une entrée de journal et le quad s'est presque écrasé dans ma voiture!

Maintenant, bien que cet auteur ait écrit son logiciel de drone en C ++, j'imagine qu'une application Java fonctionnant sous Linux pourrait très bien subir le même sort.

Selon Wikipedia:

Un système est dit en temps réel si l'exactitude totale d'une opération dépend non seulement de son exactitude logique, mais également du temps dans lequel elle est effectuée.

Donc, pour moi, cela signifie " Vous n'avez pas en temps réel si l'exactitude totale nécessite une exactitude logique et une ponctualité. "

Imaginons que j'ai écrit une application Java pour être super performante, et que j'ai "pressé le citron" pour ainsi dire, et qu'elle ne pouvait raisonnablement pas être écrite (en Java) pour être plus rapide.

Dans l'ensemble, ma question est: je cherche quelqu'un pour m'expliquer toutes / la plupart des raisons pour lesquelles une application Java exécutant n Linux ne serait pas une "application en temps réel". Autrement dit, quelles sont toutes les catégories de choses sur une pile Java / Linux qui l'empêchent "d'être opportune", et donc d'être " totalement correcte "? Comme mentionné, il semble que la purge des journaux GC et Linux puisse suspendre l'exécution, mais je suis sûr qu'il y a plus de choses en dehors de l'application Java elle-même qui pourraient entraîner un mauvais timing / performances et la faire respecter des contraintes de délais strictes. Que sont-ils?

Un logiciel est en temps réel non pas lorsqu'il est aussi rapide que possible, mais lorsqu'il est garanti qu'un processus se termine dans un intervalle de temps déterminé. Dans un système en temps réel doux, il est bon mais pas absolument nécessaire que cela soit garanti. Par exemple, dans un jeu, les calculs nécessaires pour une image doivent se terminer dans la période d'une image, sinon le taux de rafraîchissement diminuera. Cela dégrade la qualité du gameplay, mais ne le rend pas incorrect. Par exemple, Minecraft est agréable même si le jeu bégaie occasionnellement.

Dans un système difficile en temps réel, nous n'avons pas de telles libertés. Un logiciel de contrôle de vol doit réagir dans un certain délai, sinon le véhicule pourrait s'écraser. Et le matériel, le système d'exploitation et les logiciels doivent fonctionner ensemble pour prendre en charge en temps réel.

Par exemple, le système d'exploitation dispose d'un planificateur pour décider du moment d'exécution du thread. Pour un programme en temps réel, l'ordonnanceur doit garantir des plages horaires suffisamment grandes et assez fréquentes. Tout autre processus qui souhaite s'exécuter dans un tel créneau doit être interrompu au profit du processus en temps réel. Cela nécessite un planificateur avec un support explicite en temps réel.

En outre, un programme d'espace utilisateur effectuera des appels système dans le noyau. Dans un système d'exploitation en temps réel, ceux-ci doivent également être en temps réel. Par exemple, l'écriture dans un descripteur de fichier devrait être garantie pour ne pas prendre plus de x unités de temps, ce qui résoudrait le problème de journal. Cela a un impact sur la façon dont un tel appel système peut être implémenté, par exemple sur la façon dont les tampons peuvent être utilisés. Cela signifie également qu'un appel doit échouer s'il ne peut pas aboutir dans le délai requis et que le programme de l'espace utilisateur doit être préparé pour faire face à ces cas. Dans le cas de Java, la JVM et la bibliothèque standard sont également similaires au noyau et auraient besoin d'une prise en charge explicite en temps réel.

Pour tout ce qui est en temps réel, votre style de programmation changera. Si vous n'avez pas de temps sans fin, vous devez vous limiter à de petits problèmes. Toutes vos boucles doivent être limitées par une constante. Toute la mémoire peut être allouée statiquement, car vous avez une limite supérieure de taille. La récursion illimitée est interdite. Cela va à l'encontre de nombreuses bonnes pratiques, mais elles ne s'appliquent pas aux systèmes en temps réel. Par exemple, un système de journalisation peut utiliser un tampon en anneau alloué de manière statique pour stocker les messages de journal lorsqu'ils sont écrits. Une fois le début atteint, les anciens journaux seraient supprimés, ou cette condition pourrait être une erreur.

De wikipedia :

Une caractéristique clé d'un RTOS est le niveau de sa cohérence concernant le temps qu'il faut pour accepter et terminer la tâche d'une application; la variabilité est gigue.

L'important est que la gigue soit quantifiée pour que le système soit considéré en temps réel . L'article poursuit en disant que si la gigue est généralement limitée, le système est doux en temps réel . Si la gigue est toujours limitée, le système est difficile en temps réel .

À moins que les versions de Java et de Linux que vous utilisez ne soient quantifiées en termes de gigue, elles ne sont pas en temps réel. La récupération de place et l'écriture de journaux sont certainement des sources de gigue, mais même le traitement autonome (par exemple) des paquets réseau compte s'il introduit de la gigue dans vos processus.

Pour commencer, le vanilla Linux lui-même ne peut pas faire en temps réel. C'est pourquoi RTLinux a été développé.

Supposons que vous exécutiez quelques processus java sur RTLinux, ils seraient toujours considérés comme temps réel car tous ces processus sont planifiés par le noyau, c'est-à-dire que si un processus est en retard, d'autres processus peuvent toujours avoir leur tranche de temps processeur garantie.

Maintenant, si les processus java exécutent des threads verts , l'exécution de ces threads ne sera plus en temps réel puisque la JVM ne fait pas de planification en temps réel.