{"id":1136,"date":"2011-09-17T14:00:05","date_gmt":"2011-09-17T13:00:05","guid":{"rendered":"http:\/\/www.blaess.fr\/christophe\/?p=1136"},"modified":"2018-11-29T02:57:20","modified_gmt":"2018-11-29T01:57:20","slug":"efficacite-des-ipc-les-files-de-messages-posix","status":"publish","type":"post","link":"https:\/\/www.blaess.fr\/christophe\/2011\/09\/17\/efficacite-des-ipc-les-files-de-messages-posix\/","title":{"rendered":"Efficacit\u00e9 des IPC : les files de messages Posix"},"content":{"rendered":"

Un client m’a demand\u00e9 r\u00e9cemment de le conseiller sur le choix d’un m\u00e9canisme de communication entre processus pour transf\u00e9rer rapidement des donn\u00e9es entre deux applications. Il existe plusieurs syst\u00e8mes d’IPC (Inter Process Communication<\/em>), chacun avec ses avantages et inconv\u00e9nients, et j’ai eu envie de les comparer pour d\u00e9terminer le plus rapide, en fonction du type de donn\u00e9es \u00e0 transf\u00e9rer. Ce premier article est consacr\u00e9 aux message queues<\/em>, les files de messages.<\/p>\n

\n\n<\/p>\n

Posix message queues<\/h1>\n

Dans l’API standard Unix, il existe deux impl\u00e9mentations pour les files de message : les message queue<\/em> Syst\u00e8me V et les message queues<\/em> Posix. Les premi\u00e8res sont apparues dans les syst\u00e8mes Unix des ann\u00e9es 80. Elles \u00e9taient efficaces mais disposaient d’une interface de programmation un peu bancale : il fallait r\u00e9server dans le bloc de donn\u00e9es \u00e0 envoyer quatre octets pour stocker la priorit\u00e9 du message. Ceci n’est pas tr\u00e8s d\u00e9rangeant, mais pouvait n\u00e9cessiter quand m\u00eame une recopie syst\u00e9matique du message s’il \u00e9tait produit par une biblioth\u00e8que ind\u00e9pendante par exemple. En outre, comme l’ensemble des IPC Syst\u00e8me V, ces message queues<\/em> ne s’int\u00e9graient pas dans le concept g\u00e9n\u00e9ral des descripteurs de fichiers Unix.<\/p>\n

Dans les ann\u00e9es 90, avec la volont\u00e9 d’uniformiser les interfaces de programmation des syst\u00e8mes Unix par l’interm\u00e9diaire de la norme Posix, sont apparues de nouvelles files de message, dont l’interface est plus simple, et dont les descripteurs sont plus proches de ceux des fichiers. Les message queues<\/em> Posix n’ont \u00e9t\u00e9 int\u00e9gr\u00e9es qu’assez tardivement dans Linux (dans la version 2.6.10 si ma m\u00e9moire est bonne).<\/p>\n

Les appels-syst\u00e8me qui nous concernent sont :<\/p>\n

#include <mqueue.h>\n\nmqd_t   mq_open<\/strong>    (const char * nom<\/em>, int flags<\/em>, mode_t mode<\/em>, struct mq_attr * attr<\/em>);\nint     mq_send<\/strong>    (mqd_t mq<\/em>, const char * msg<\/em>, size_t lg<\/em>, unsigned int prio<\/em>);\nssize_t mq_receive<\/strong> (mqd_t mq<\/em>, char * msg<\/em>, size_t lg<\/em>, unsigned int * prio<\/em>);\nint     mq_close<\/strong>   (mqd_t mq<\/em>);\nint     mq_unlink<\/strong>  (const char * nom<\/em>);<\/pre>\n
On peut se reporter aux pages de manuels respectives de ces fonctions pour avoir plus de d\u00e9tails.<\/p>\n
Transfert \u00e0 faible d\u00e9bit<\/h2>\n
Voici un petit programme qui va nous permettre de mesurer le temps de transfert d’un message d’un processus \u00e0 un autre, pour des messages relativement courts (8 octets), avec un faible d\u00e9bit.<\/p>\n
Nous cr\u00e9eons deux processus, un \u00e9metteur qui envoie toutes les secondes dans la file un message contenant l’heure actuelle (secondes + microsecondes) et un r\u00e9cepteur qui compare la valeur re\u00e7ue avec l’heure qu’il vient de lire lui-m\u00eame. Notez que sur la plupart des machines actuelles, la lecture de l’heure \u00e0 l’aide de gettimeofday()<\/code> dure environ une micro-seconde. Le d\u00e9bit \u00e9tant faible (un message par seconde), nous pouvons afficher directement la diff\u00e9rence (en micro-secondes).<\/p>\n
Pour que le fonctionnement soit optimal, il conviendra de placer l’\u00e9metteur et le r\u00e9cepteur sur deux c\u0153urs ou deux processeurs diff\u00e9rents.<\/p>\n
Voici le premier \u00e9metteur qui envoie r\u00e9guli\u00e8rement l’heure dans la file de messages. Les fichiers-source ainsi que le fichier Makefile<\/code> se trouvent dans cette archive<\/a>.<\/p>\n
emetteur-01.c<\/strong>:\n#include <fcntl.h>\n#include <mqueue.h>\n#include <stdio.h>\n#include <stdlib.h>\n#include <unistd.h>\n#include <sys\/time.h>\n\nint main(int argc,char * argv[])\n{\n    mqd_t mq;\n    struct timeval heure;\n\n    if (argc != 2) {\n        fprintf(stderr, \"usage: %s nom_file_message\\n\", argv[0]);\n        exit(EXIT_FAILURE);\n    }\n\n    mq = mq_open<\/strong>(argv[1], O_WRONLY | O_CREAT, 0600, NULL);\n    if (mq == (mqd_t) -1) {\n        perror(argv[1]);\n        exit(EXIT_FAILURE);\n    }\n    while (1) {\n        gettimeofday<\/strong>(& heure, NULL);\n        mq_send<\/strong>(mq, (char *) & heure, sizeof(heure), 1);\n        sleep(1);\n    }\n    return EXIT_SUCCESS;\n}<\/pre>\n
Et voici le premier r\u00e9cepteur. On notera que dans l’API des message queues<\/em> Posix, la fonction mq_receive()<\/code> r\u00e9clame un buffer capable de contenir (au moins) le plus grand message susceptible d’\u00eatre v\u00e9hicul\u00e9e par la file. Cette valeur est obtenue avec mq_getattr()<\/code>.<\/p>\n
recepteur-01.c:<\/strong>\n#include <fcntl.h>\n#include <mqueue.h>\n#include <stdio.h>\n#include <stdlib.h>\n#include <unistd.h>\n#include <sys\/time.h>\n\nint main(int argc,char * argv[])\n{\n    mqd_t mq;\n    int taille;\n    char * buffer;\n    long int duree;\n    struct mq_attr attr;\n    struct timeval heure;\n    struct timeval * recue;\n\n    if (argc != 2) {\n        fprintf(stderr, \"usage: %s nom_file_message\\n\", argv[0]);\n        exit(EXIT_FAILURE);\n    }\n\n    mq = mq_open<\/strong>(argv[1], O_RDONLY | O_CREAT, 0600, NULL);\n    if (mq == (mqd_t) -1) {\n        perror(argv[1]);\n        exit(EXIT_FAILURE);\n    }\n\n    if (mq_getattr<\/strong>(mq, & attr) != 0) {\n        perror(\"mq_getattr\");\n        exit(EXIT_FAILURE);\n    }\n    taille = attr.mq_msgsize;\n    buffer = malloc(taille);\n\n    if (buffer == NULL) {\n        perror(\"malloc\");\n        exit(EXIT_FAILURE);\n    }\n\n    recue = (struct timeval *) buffer;\n    while (1) {\n        mq_receive<\/strong>(mq, buffer, taille, NULL);\n        gettimeofday(& heure, NULL);\n        duree  = heure.tv_sec - recue->tv_sec;\n        duree *= 1000000;\n        duree += heure.tv_usec - recue->tv_usec;\n        fprintf(stdout, \"%ld usec\\n\", duree);\n    }\n    return EXIT_SUCCESS;\n}<\/pre>\n
Pour l’ex\u00e9cution, je lance sur un premier terminal :<\/p>\n
$ taskset -c 0 .\/recepteur-01 \/essai<\/strong><\/pre>\n
Notez que le nom de la file de message (essai<\/code>) doit obligatoirement \u00eatre pr\u00e9c\u00e9d\u00e9 d’un slash ‘\/<\/code>‘.<\/p>\n
Puis sur un second terminal :<\/p>\n
$ taskset -c 1 .\/emetteur-01 \/essai<\/strong><\/pre>\n
Les r\u00e9sultats s’affichent dans le premier terminal :<\/p>\n
$ taskset -c 0 .\/recepteur-01 \/essai<\/strong>\n16 usec\n14 usec\n14 usec\n15 usec\n13 usec\n12 usec\n13 usec\n15 usec\n14 usec\n(Contr\u00f4le-C)<\/em><\/strong>\n$<\/pre>\n
Sur ce syst\u00e8me – Intel Core 2 Quad<\/em> avec Linux 2.6.38 g\u00e9n\u00e9rique Ubuntu – le temps de passage d’un message sporadique est donc d’une quinzaine de micro-secondes. Essayons \u00e0 pr\u00e9sent avec un d\u00e9bit plus \u00e9lev\u00e9.<\/p>\n
Transfert d’un message \u00e0 haut d\u00e9bit<\/h2>\n
Nous allons \u00e0 pr\u00e9sent envoyer des messages aussi vite que possible. Pour cela, nous retirons simplement le sommeil d’une seconde de l’exemple pr\u00e9c\u00e9dent :<\/p>\n
emetteur-02.c<\/strong>:\n#include <fcntl.h>\n#include <mqueue.h>\n#include <stdio.h>\n#include <stdlib.h>\n#include <unistd.h>\n#include <sys\/time.h>\n\nint main(int argc,char * argv[])\n{\n    mqd_t mq;\n    struct timeval heure;\n\n    if (argc != 2) {\n        fprintf(stderr, \"usage: %s nom_file_message\\n\", argv[0]);\n        exit(EXIT_FAILURE);\n    }\n\n    mq = mq_open<\/strong>(argv[1], O_WRONLY | O_CREAT, 0600, NULL);\n    if (mq == (mqd_t) -1) {\n        perror(argv[1]);\n        exit(EXIT_FAILURE);\n    }\n    while (1) {\n        gettimeofday<\/strong>(& heure, NULL);\n        mq_send<\/strong>(mq, (char *) & heure, sizeof(heure), 1);\n    }\n    return EXIT_SUCCESS;\n}<\/pre>\n
Pour la r\u00e9ception, le probl\u00e8me est plus compliqu\u00e9. Nous ne pouvons pas nous permettre de faire un fprintf()<\/code> \u00e0 chaque message, car cela perturberait l’ex\u00e9cution du programme. J’ai donc d\u00e9cid\u00e9 d’afficher r\u00e9guli\u00e8rement les dur\u00e9es minimale, maximale et moyenne sur une p\u00e9riode donn\u00e9e, de l’ordre d’une seconde (calcul\u00e9e avec les r\u00e9sultats pr\u00e9c\u00e9dents).<\/p>\n
recepteur-02.c:<\/strong>\n#include <fcntl.h>\n#include <mqueue.h>\n#include <stdio.h>\n#include <stdlib.h>\n#include <unistd.h>\n#include <sys\/time.h>\n\nint main(int argc,char * argv[])\n{\n    mqd_t mq;\n    int taille;\n    char * buffer;\n    struct mq_attr attr;\n    struct timeval heure;\n    struct timeval * recue;\n\n    int nb_messages;\n    long int duree;\n    long int duree_max;\n    long int duree_min;\n    long int somme_durees;\n\n    if (argc != 2) {\n        fprintf(stderr, \"usage: %s nom_file_message\\n\", argv[0]);\n        exit(EXIT_FAILURE);\n    }\n\n    mq = mq_open<\/strong>(argv[1], O_RDONLY | O_CREAT, 0600, NULL);\n    if (mq == (mqd_t) -1) {\n        perror(argv[1]);\n        exit(EXIT_FAILURE);\n    }\n\n    if (mq_getattr<\/strong>(mq, & attr) != 0) {\n        perror(\"mq_getattr\");\n        exit(EXIT_FAILURE);\n    }\n\n    taille = attr.mq_msgsize;\n    buffer = malloc(taille);\n    if (buffer == NULL) {\n        perror(\"malloc\");\n        exit(EXIT_FAILURE);\n    }\n\n    recue = (struct timeval *) buffer;\n    while (1) {\n        nb_messages = 0;\n        duree_max = 0;\n        duree_min = -1;\n        somme_durees = 0;\n        do {\n            mq_receive<\/strong>(mq, buffer, taille, NULL);\n            gettimeofday(& heure, NULL);\n            duree  = heure.tv_sec - recue->tv_sec;\n            duree *= 1000000;\n            duree += heure.tv_usec - recue->tv_usec;\n            if (nb_messages > 0) { \/\/ Ignorer le premier message (retarde)\n                if (duree_max < duree)\n                    duree_max = duree;\n                if ((duree_min == -1) || (duree_min > duree))\n                    duree_min = duree;\n                somme_durees += duree;\n            }\n            nb_messages ++;\n        } while (nb_messages < 100000); \/\/ arbitraire, de l'ordre de la seconde\n        fprintf(stdout, \"min =%3ld   max =%3ld moy=%5.1f\\n\",\n            duree_min, duree_max, ((float) somme_durees) \/ (nb_messages - 1));\n    }\n    return EXIT_SUCCESS;\n}<\/pre>\n
Comme pr\u00e9c\u00e9demment, je lance les deux processus sur deux c\u0153urs distincts. Voici les r\u00e9sultats :<\/p>\n
$ taskset -c 0 .\/recepteur-02 \/essai<\/strong>\nmin =  1   max = 78 moy=  7.8\nmin =  1   max =102 moy=  6.9\nmin =  1   max = 65 moy=  7.5\nmin =  1   max = 61 moy=  7.4\nmin =  1   max = 70 moy=  5.5\nmin =  1   max = 64 moy=  6.6\nmin =  1   max = 63 moy=  5.7\nmin =  1   max = 75 moy=  5.5\nmin =  1   max = 84 moy=  5.6\nmin =  1   max = 71 moy=  6.8\nmin =  1   max = 68 moy=  6.3\nmin =  1   max =688 moy=  6.8\nmin =  1   max = 69 moy=  5.7\nmin =  1   max = 69 moy=  7.7\nmin =  1   max = 68 moy=  6.7\nmin =  2   max = 69 moy=  7.8\nmin =  2   max =102 moy=  6.7\nmin =  1   max = 70 moy=  5.6\nmin =  1   max = 73 moy=  6.3\nmin =  1   max = 63 moy=  6.2\nmin =  1   max = 71 moy=  4.8\nmin =  1   max = 87 moy=  5.5\nmin =  3   max = 74 moy=  6.4\nmin =  1   max = 71 moy=  4.1\nmin =  1   max = 71 moy=  8.1\nmin =  1   max = 80 moy=  5.8\nmin =  1   max = 76 moy=  7.2\nmin =  1   max =177 moy=  7.9\nmin =  1   max = 55 moy=  5.4\nmin =  2   max = 74 moy=  8.5\nmin =  4   max = 74 moy=  8.2\nmin =  3   max = 77 moy=  6.4\n^C\n$<\/pre>\n
En fait, le temps moyen lorsqu’on envoie des messages fr\u00e9quents est plut\u00f4t de l’ordre de 8 micro-secondes alors qu’avec des messages rares, il \u00e9tait de 15 micro-secondes environ. Il y a naturellement de temps \u00e0 autres des temps de transferts plus long \u00e0 cause de l’activit\u00e9 du syst\u00e8me. Si l’on ordonnance en temps-r\u00e9el les deux t\u00e2ches, les dur\u00e9es maximales sont plus stables. Il faut toutefois obtenir les droits root<\/em>.<\/p>\n
# chrt -f 40 taskset -c 1 .\/emetteur-02 \/essai<\/strong><\/pre>\n
et sur l’autre terminal<\/p>\n
#  chrt -f 40 taskset -c 0 .\/recepteur-02 \/essai<\/strong>\nmin =  1   max = 80 moy=  6.1\nmin =  1   max = 67 moy=  6.3\nmin =  1   max = 64 moy=  5.3\nmin =  1   max = 70 moy=  8.2\nmin =  3   max = 67 moy=  8.8\nmin =  2   max = 62 moy=  5.7\nmin =  2   max = 62 moy=  7.8\nmin =  1   max = 59 moy=  7.5\nmin =  1   max = 63 moy=  6.6\nmin =  2   max = 63 moy=  6.4\nmin =  2   max = 66 moy=  7.2\nmin =  1   max = 58 moy=  5.9\nmin =  1   max = 55 moy=  6.4\nmin =  2   max = 65 moy=  8.5\nmin =  2   max = 71 moy=  9.0\nmin =  2   max = 81 moy=  8.5\nmin =  1   max = 63 moy=  7.5\nmin =  1   max = 66 moy=  8.1\nmin =  3   max = 69 moy=  8.7\nmin =  2   max = 64 moy=  7.2\nmin =  1   max = 62 moy=  5.7\nmin =  1   max = 63 moy=  7.2\nmin =  1   max = 65 moy=  8.2\nmin =  2   max = 64 moy=  7.2\nmin =  1   max = 68 moy=  6.0\nmin =  1   max = 69 moy=  6.3\nmin =  1   max = 60 moy=  6.5\nmin =  1   max = 67 moy=  7.3\nmin =  1   max = 62 moy=  7.1\nmin =  2   max = 62 moy=  8.6\nmin =  1   max = 57 moy=  6.7\nmin =  2   max = 72 moy=  8.7\nmin =  1   max = 85 moy=  7.9\nmin =  1   max = 72 moy=  7.1\nmin =  1   max = 58 moy=  5.0\nmin =  1   max = 64 moy=  5.8\nmin =  2   max = 73 moy=  7.4\nmin =  1   max = 55 moy=  7.1\nmin =  1   max = 62 moy=  7.3\nmin =  1   max = 66 moy=  8.3\nmin =  1   max = 58 moy=  5.2\nmin =  5   max = 75 moy=  9.3\nmin =  3   max = 68 moy=  9.1<\/pre>\n
Nos messages sont tr\u00e8s courts, deux entiers de 32 bits, soient 8 octets en tout. J’ai fait quelques exp\u00e9riences en augmentant leur taille (jusqu’\u00e0 64 ko), sans constater de diff\u00e9rence sensible de temps de passage d’un message.<\/p>\n
Conclusion<\/h1>\n
Nous pouvons donc estimer que sur ce syst\u00e8me le temps de transfert d’un message d’un processus \u00e0 l’autre par les files Posix est d’environ 8 micro-secondes en moyenne, avec des pics de quelques dizaines de micro-secondes. Nous comparerons ces valeurs avec d’autres m\u00e9canismes IPC dans les prochains articles.<\/p>","protected":false},"excerpt":{"rendered":"
Un client m’a demandé récemment de le conseiller sur le choix d’un mécanisme de communication entre processus pour transférer rapidement des données entre deux applications. Il existe plusieurs systèmes d’IPC (Inter Process Communication), chacun avec ses avantages et inconvénients, et j’ai eu envie de les comparer pour déterminer le plus rapide, en fonction du type […]<\/p>","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[8,14],"tags":[],"class_list":["post-1136","post","type-post","status-publish","format-standard","hentry","category-linux-2","category-temps-reel"],"_links":{"self":[{"href":"https:\/\/www.blaess.fr\/christophe\/wp-json\/wp\/v2\/posts\/1136","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.blaess.fr\/christophe\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.blaess.fr\/christophe\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.blaess.fr\/christophe\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.blaess.fr\/christophe\/wp-json\/wp\/v2\/comments?post=1136"}],"version-history":[{"count":1,"href":"https:\/\/www.blaess.fr\/christophe\/wp-json\/wp\/v2\/posts\/1136\/revisions"}],"predecessor-version":[{"id":5427,"href":"https:\/\/www.blaess.fr\/christophe\/wp-json\/wp\/v2\/posts\/1136\/revisions\/5427"}],"wp:attachment":[{"href":"https:\/\/www.blaess.fr\/christophe\/wp-json\/wp\/v2\/media?parent=1136"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.blaess.fr\/christophe\/wp-json\/wp\/v2\/categories?post=1136"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.blaess.fr\/christophe\/wp-json\/wp\/v2\/tags?post=1136"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}