Je suis actuellement confronté à un problème de mémoire partagée entre
plusieurs processus s'exécutant dans un environnement windows NT.
L'application a recours au dispositif microsoft de mappage de
fichiers,
fonctions CreateFileMapping, MapViewOfFile, et UnmapViewOfFile.
Par contre, il n'y a aucun mécanisme de synchronisation entre les
différents processus pour accéder à cette mémoire partagée.
Cette synchronisation est-elle déjà intégrée dans les fonctions
ci-dessus OU doit-on la prévoir en recourant par exemple aux
sémaphores ?
Merci d'avance pour vos réponses.
A bientôt.
Louis.
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Patrick 'Zener' Brunet
Bonjour.
"mpe-d3l" a écrit dans le message de news:
Je suis actuellement confronté à un problème de mémoire partagée entre plusieurs processus s'exécutant dans un environnement windows NT. L'application a recours au dispositif microsoft de mappage de fichiers, fonctions CreateFileMapping, MapViewOfFile, et UnmapViewOfFile. Par contre, il n'y a aucun mécanisme de synchronisation entre les différents processus pour accéder à cette mémoire partagée. Cette synchronisation est-elle déjà intégrée dans les fonctions ci-dessus OU doit-on la prévoir en recourant par exemple aux sémaphores ? Merci d'avance pour vos réponses.
Pour autant que je me souvienne, par défaut la gestion du partage est faite au niveau du fichier entier. CreateFileMapping() prend un argument hFile rendu par un CreateFile() préalable, et c'est là que vous pouvez spécifier un flag FILE_SHARE_XXX.
Evidemment pour de la mémoire partagée, ça n'est pas applicable et à mon avis ça se comprend parce qu'il faut de toute manière implémenter un protocole d'échange, le polling d'un pseudo-booléen dans la zone de mémoire étant une technique très imprévisible et donc très mauvaise.
A priori donc vous avez fonctionnellement besoin au minimum d'un Mutex à l'entrée du segment de code d'échange, et d'un Signal à la sortie pour forcer le process client à attendre que le serveur ait bien pris livraison du paquet avant de rendre le Mutex. Et éventuellement, selon vos protocoles, d'une signalétique plus complexe. Donc la synchro inter-process doit reposer là-dessus. Vous pouvez d'ailleurs créer plusieurs zones d'échange distinctes dans le même fichier.
La gestion du partage du fichier d'échange est encore autre chose, il devrait être initié par le process maître (serveur), les autres venant s'y connecter ensuite. Qui lance les processes, comment se négocie la terminaison de l'ensemble, tout ça dépend de vos choix de conception.
Et si vous pouvez avoir plusieurs instances de votre process serveur et de son jeu de clients, c'est encore plus compliqué, d'autant que COM ne vous permet pas vraiment de choisir une instance de serveur ;-)
Au fait, n'oubliez pas de faire des flush quand vous modifiez la mémoire partagée, ça ne se fait pas tout seul et vous pourriez avoir des surprises que vous attribueriez à tort à la synchro =<:-[=8 Mais quand ça marche bien on se sent si heureux :-}}}}}}}}
Cordialement,
--
/************************************************************** * Patrick BRUNET @ ZenerTopia * E-mail: lien sur http://zener131.free.fr/ContactMe **************************************************************/ <8#--X--< filtré par Avast! 4 Home
Bonjour.
"mpe-d3l" <mpe-d3l@myamail.com> a écrit dans le message de news:
b8f24591.0411110229.7474a243@posting.google.com...
Je suis actuellement confronté à un problème de mémoire partagée entre
plusieurs processus s'exécutant dans un environnement windows NT.
L'application a recours au dispositif microsoft de mappage de
fichiers,
fonctions CreateFileMapping, MapViewOfFile, et UnmapViewOfFile.
Par contre, il n'y a aucun mécanisme de synchronisation entre les
différents processus pour accéder à cette mémoire partagée.
Cette synchronisation est-elle déjà intégrée dans les fonctions
ci-dessus OU doit-on la prévoir en recourant par exemple aux
sémaphores ?
Merci d'avance pour vos réponses.
Pour autant que je me souvienne, par défaut la gestion du partage est faite
au niveau du fichier entier.
CreateFileMapping() prend un argument hFile rendu par un CreateFile()
préalable, et c'est là que vous pouvez spécifier un flag FILE_SHARE_XXX.
Evidemment pour de la mémoire partagée, ça n'est pas applicable et à mon
avis ça se comprend parce qu'il faut de toute manière implémenter un
protocole d'échange, le polling d'un pseudo-booléen dans la zone de mémoire
étant une technique très imprévisible et donc très mauvaise.
A priori donc vous avez fonctionnellement besoin au minimum d'un Mutex à
l'entrée du segment de code d'échange, et d'un Signal à la sortie pour
forcer le process client à attendre que le serveur ait bien pris livraison
du paquet avant de rendre le Mutex. Et éventuellement, selon vos protocoles,
d'une signalétique plus complexe. Donc la synchro inter-process doit reposer
là-dessus. Vous pouvez d'ailleurs créer plusieurs zones d'échange distinctes
dans le même fichier.
La gestion du partage du fichier d'échange est encore autre chose, il
devrait être initié par le process maître (serveur), les autres venant s'y
connecter ensuite. Qui lance les processes, comment se négocie la
terminaison de l'ensemble, tout ça dépend de vos choix de conception.
Et si vous pouvez avoir plusieurs instances de votre process serveur et de
son jeu de clients, c'est encore plus compliqué, d'autant que COM ne vous
permet pas vraiment de choisir une instance de serveur ;-)
Au fait, n'oubliez pas de faire des flush quand vous modifiez la mémoire
partagée, ça ne se fait pas tout seul et vous pourriez avoir des surprises
que vous attribueriez à tort à la synchro =<:-[=8
Mais quand ça marche bien on se sent si heureux :-}}}}}}}}
Cordialement,
--
/**************************************************************
* Patrick BRUNET @ ZenerTopia
* E-mail: lien sur http://zener131.free.fr/ContactMe
**************************************************************/
<8#--X--< filtré par Avast! 4 Home
Je suis actuellement confronté à un problème de mémoire partagée entre plusieurs processus s'exécutant dans un environnement windows NT. L'application a recours au dispositif microsoft de mappage de fichiers, fonctions CreateFileMapping, MapViewOfFile, et UnmapViewOfFile. Par contre, il n'y a aucun mécanisme de synchronisation entre les différents processus pour accéder à cette mémoire partagée. Cette synchronisation est-elle déjà intégrée dans les fonctions ci-dessus OU doit-on la prévoir en recourant par exemple aux sémaphores ? Merci d'avance pour vos réponses.
Pour autant que je me souvienne, par défaut la gestion du partage est faite au niveau du fichier entier. CreateFileMapping() prend un argument hFile rendu par un CreateFile() préalable, et c'est là que vous pouvez spécifier un flag FILE_SHARE_XXX.
Evidemment pour de la mémoire partagée, ça n'est pas applicable et à mon avis ça se comprend parce qu'il faut de toute manière implémenter un protocole d'échange, le polling d'un pseudo-booléen dans la zone de mémoire étant une technique très imprévisible et donc très mauvaise.
A priori donc vous avez fonctionnellement besoin au minimum d'un Mutex à l'entrée du segment de code d'échange, et d'un Signal à la sortie pour forcer le process client à attendre que le serveur ait bien pris livraison du paquet avant de rendre le Mutex. Et éventuellement, selon vos protocoles, d'une signalétique plus complexe. Donc la synchro inter-process doit reposer là-dessus. Vous pouvez d'ailleurs créer plusieurs zones d'échange distinctes dans le même fichier.
La gestion du partage du fichier d'échange est encore autre chose, il devrait être initié par le process maître (serveur), les autres venant s'y connecter ensuite. Qui lance les processes, comment se négocie la terminaison de l'ensemble, tout ça dépend de vos choix de conception.
Et si vous pouvez avoir plusieurs instances de votre process serveur et de son jeu de clients, c'est encore plus compliqué, d'autant que COM ne vous permet pas vraiment de choisir une instance de serveur ;-)
Au fait, n'oubliez pas de faire des flush quand vous modifiez la mémoire partagée, ça ne se fait pas tout seul et vous pourriez avoir des surprises que vous attribueriez à tort à la synchro =<:-[=8 Mais quand ça marche bien on se sent si heureux :-}}}}}}}}
Cordialement,
--
/************************************************************** * Patrick BRUNET @ ZenerTopia * E-mail: lien sur http://zener131.free.fr/ContactMe **************************************************************/ <8#--X--< filtré par Avast! 4 Home
