100 sec sous Linux?

J’ai un système de stream de données asynchrone écrit en C ++. Dans l’architecture de stream de données, l’application est un ensemble d’instances de composants, initialisées au démarrage, puis communiquent entre elles par des messages prédéfinis. Il existe un type de composant appelé Pulsar, qui fournit un “message de signal d’horloge” aux autres composants qui s’y connectent (par exemple, le délai). Il déclenche un message (appelle l’API du répartiteur de stream de données) toutes les X ms, X étant la valeur du paramètre “frequency”, qui est donnée en ms.

Bref, la tâche consiste simplement à appeler une fonction (méthode) tous les X ms. La question est: quelle est la meilleure façon / officielle de le faire? Y a-t-il un motif pour cela?

Il y a quelques méthodes que j’ai trouvées:

Utilisez SIGALRM . Je pense que la signalisation ne convient pas à cette fin. Bien que la résolution soit de 1 seconde, c’est trop rare.
Utilisez l’interruption matérielle . Je n’ai pas besoin de cette précision. En outre, je connais l’utilisation de la solution liée à HW (le serveur est compilé pour plusieurs plates-formes, par exemple ARM).
Mesurez le temps écoulé et utilisez-le () jusqu’au prochain appel. Je ne suis pas sûr que ce soit le meilleur moyen de mesurer le temps d’appeler les appels système liés à l’heure par 5 threads, 10 fois par seconde – mais je me trompe peut-être.
Utilisez les fonctions du kernel RealTime . Je n’en sais rien. De plus, je n’ai pas besoin d’appels précis, ce n’est pas un atomreactor, et je ne peux pas installer le kernel RT sur certaines plates-formes (le kernel 2.6.x est également disponible).

Peut-être que la meilleure réponse est une courte partie commentée du code source d’un lecteur audio / vidéo (que je ne peux pas trouver / comprendre par moi-même).

UPDATE (demandé par @MSalters): Le co-auteur du projet DF utilise Mac OSX, nous devons donc trouver une solution qui fonctionne sur la plupart des op. systèmes, pas seulement sous Linux. Peut-être, à l’avenir, il y aura un périphérique cible qui utilise BSD, ou quelque Linux restreint.

Pour être honnête, je pense que devoir avoir un “pulsar” dans ce qui prétend être un système de stream de données asynchrone est un défaut de conception. Soit il est asynchrone ou il a un événement d’horloge de synchronisation.

Si vous avez un composant qui a besoin d’un délai, demandez-en un, via boost :: asio :: deadline_timer.async_wait ou l’une des solutions de niveau inférieur (select () / epoll () / timer_create () / etc). Dans tous les cas, la solution C ++ la plus efficace est probablement les timers boost.asio, car ils utiliseraient tout ce qui est le plus efficace sur votre version du kernel Linux.

Si vous n’avez pas besoin de garanties usleep temps réel, vous usleep faire le travail. Si vous voulez des garanties matérielles en temps réel, une fonction basée sur le kernel ou basée sur une interruption sera nécessaire.

Une alternative aux approches mentionnées précédemment consiste à utiliser le support Timer FD dans Linux Kernels 2.6.25+ (à peu près toute dissortingbution proche de “current”). Les minuteurs FD offrent un peu plus de flexibilité que les approches précédentes.

Négliger la question du design (qui, à mon avis, est une question intéressante, mais mérite son propre fil) …

Je commencerais par concevoir une idée d’interruption et utiliser des signaux ou une fonction du kernel pour interrompre chaque X usec. Je retarderais les fonctions de sumil jusqu’à ce que les autres idées soient trop douloureuses.