La m\u00e9thode de communication entre processus la plus performante lorsqu’on doit transf\u00e9rer des donn\u00e9es volumineuses est l’emploi de zones de m\u00e9moires partag\u00e9es. Standardis\u00e9 par Posix, il s’agit d’un m\u00e9canisme extr\u00e9mement efficace. Toutefois, il faut penser \u00e0 synchroniser les acc\u00e8s, afin d’\u00e9viter les modifications concurrentes des donn\u00e9es partag\u00e9es ou la modification d’une zone pendant sa consultation par un autre processus.
\n\n<\/p>\n
Pour partager une zone de m\u00e9moire entre deux processus, chacun doit d’abord obtenir un descripteur avec l’appel-syst\u00e8me suivant.<\/p>\n
#include <sys\/mman.h>\nint shm_open<\/strong>(const char * nom,<\/em> int flags<\/em>, mode_t mode<\/em>);<\/pre>\nLe
nom<\/code><\/em> est celui que nous attribuons \u00e0 la zone m\u00e9moire. Il doit \u00eatre fourni identique dans les deux processus. La seule contrainte est que ce nom doit commencer par un caract\u00e8re slash<\/em>\/<\/code><\/strong>.
\nLesflags<\/code><\/em> sont les m\u00eames que ceux de l’appel-syst\u00e8meopen()<\/code>, en g\u00e9n\u00e9ral on emploieO_CREAT | O_RDWR<\/code>.
\nLemode<\/code><\/em> enfin correspond aux droits d’acc\u00e8s en lecture, \u00e9criture, ex\u00e9cution par le propri\u00e9taire, le groupe, et les autres utilisateurs. La valeur octale0600<\/code> repr\u00e9sente les droits classiques pour un partage entre processus appartenant tous \u00e0 un m\u00eame utilisateur.<\/p>\nL’appel
shm_open()<\/code> renvoie un descripteur au m\u00eame titre que les descripteurs de fichiers obtenus avecopen()<\/code>,socket()<\/code>,pipe()<\/code>, etc. Nous allons donc dimensionner le bloc de m\u00e9moire partag\u00e9e en utilisant un appel-syst\u00e8me habituellement r\u00e9serv\u00e9 aux fichiers.<\/p>\nint ftruncate<\/strong>(int fd<\/em>, off_t longueur<\/em>);<\/pre>\nIci
fd<\/code><\/em> est le descripteur fourni parshm_open()<\/code>. Cette op\u00e9ration n’est n\u00e9cessaire que pour dimensionner initialement le segment de m\u00e9moire, mais elle est inoffensive si on la r\u00e9p\u00e8te \u00e0 chaque ouverture.<\/p>\nEnfin, nous allons projeter le bloc de m\u00e9moire partag\u00e9e dans notre espace d’adressage en utilisant l’appel-suivant.<\/p>\n
void * mmap<\/strong>(void * adresse<\/em>, size_t longueur<\/em>, int droits<\/em>,\n int flags<\/em>, int fd<\/em>, off_t offset<\/em>);<\/pre>\nL’argument
adresse<\/code><\/em> sera laiss\u00e9NULL<\/code>, le noyau cherchera une place libre dans notre espace d’adressage, et nous renverra l’adresse en retour demmap()<\/code>. Lalongueur<\/code><\/em> est celle de la zone partag\u00e9e. Les droits vaudrontPROT_READ | PROT_WRITE<\/code> pour permettre lecture et \u00e9criture sur la m\u00e9moire. L’argumentflags<\/code><\/em> contiendraMAP_SHARED<\/code> pour indiquer que la projection doit \u00eatre partag\u00e9e entre processus. Enfinfd<\/code><\/em> etoffset<\/code><\/em> repr\u00e9senteront le descripteur fourni parshm_open()<\/code> et le d\u00e9calage de la projection par rapport au d\u00e9but de la zone de m\u00e9moire partag\u00e9e (z\u00e9ro bien s\u00fbr).<\/p>\nDans le programme suivant, nous partagerons une simple structure
timeval<\/code> contenant l’heure. Cette zone de m\u00e9moire pourrait \u00eatre beaucoup plus grande, des kilo-octets voire des m\u00e9ga-octets sans diff\u00e9rence notable de performance.<\/p>\nS\u00e9maphores<\/h1>\n
Pour prot\u00e9ger les acc\u00e8s concurrents, il est d’usage d’employer un s\u00e9maphore avec un compteur initialis\u00e9 \u00e0 1, chaque processus prenant le s\u00e9maphore (la prise est bloquante quant le compteur est nul), effectuant ses modifications et restituant le s\u00e9maphore. C’est le m\u00eame principe que celui des mutex dont on se sert entre threads du m\u00eame processus.<\/p>\n
Pour partager un s\u00e9maphore entre processus, on emploie g\u00e9n\u00e9ralement un s\u00e9maphore nomm\u00e9<\/em>. Celui-ci s’obtient avec l’appel-syst\u00e8me suivant.<\/p>\n
int sem_open<\/strong>(const char * nom<\/em>, int flags<\/em>,\n mode_t mode<\/em>, int valeur<\/em>);<\/pre>\nLe
nom<\/code><\/em> est soumis aux m\u00eames r\u00e8gles que celui utilis\u00e9 parshm_open()<\/code>. Les flags serontO_CREAT | O_RDWR<\/code>, le mode0600<\/code> et lavaleur<\/code><\/em> est celle du s\u00e9maphore s’il y a cr\u00e9ation (sinon l’argument est ignor\u00e9).<\/p>\nLa prise et le rel\u00e2chement du s\u00e9maphore se font avec<\/p>\n
int sem_wait<\/strong>(sem_t * sem<\/em>);\nint sem_post<\/strong>(sem_t * sem<\/em>);<\/pre>\nIl existe des variantes non bloquantes ou temporis\u00e9es \u00e9galement.<\/p>\n
Dans le programme suivant nous allons utiliser le s\u00e9maphore d’une mani\u00e8re un peu d\u00e9voy\u00e9e, mais souvent employ\u00e9e dans les syst\u00e8mes temps-r\u00e9el : un processus va r\u00e9aliser uniquement des
sem_wait()<\/code> (ce qui le bloquera r\u00e9guli\u00e8rement), et l’autre uniquement dessem_post()<\/code> (pour d\u00e9bloquer son partenaire).<\/p>\nDestructions des ressources partag\u00e9es<\/h2>\n
Dans les deux programmes que nous emploierons ci-dessous, nous avons pris soin juste apr\u00e8s ouverture d’une ressource partag\u00e9e de d\u00e9truire son nom avec
shm_unlink()<\/code> ousem_unlink()<\/code>. Comme les processus qui utiliserons ces ressources sont deux fils du processus original, ils disposeront des descripteurs (de m\u00e9moire ou de s\u00e9maphore) d\u00e9j\u00e0 ouverts. La destruction des ressources ne se produira effectivement que lorsqu’il n’y aura plus de processus utilisateur – autrement dit \u00e0 la fin de nos programmes.<\/p>\nCommunications rares par m\u00e9moire partag\u00e9e<\/h1>\n
Comme dans nos articles pr\u00e9c\u00e9dents sur les files de messages<\/a> et signaux temps-r\u00e9el<\/a>, nous allons commencer par un \u00e9change sporadique de donn\u00e9es (toutes les 0,5 secondes).<\/p>\n
Un processus \u00e9crit l’heure actuelle dans la m\u00e9moire partag\u00e9e et d\u00e9bloque le s\u00e9maphore.<\/p>\n
L’autre processus qui \u00e9tait bloqu\u00e9 sur le s\u00e9maphore est r\u00e9veill\u00e9, et compare l’heure actuelle avec celle mesur\u00e9e par son confr\u00e8re. La dur\u00e9e est affich\u00e9e en micro-secondes sur la sortie standard.<\/p>\n
Les deux processus sont plac\u00e9s sur deux CPU s\u00e9par\u00e9s (si possible) afin d’\u00e9viter les effets d’ordonnancement.<\/p>\n