Bonjour a tous,
Je cherche en ce moment a produire sous linux une synchronisation entre thread et non entre processus. La solution du mutex fonctionne mais prends pas mal de temps. En effet elle utilise un mécanisme kernel space (obligatoire pour synchroniser des processus entre eux).

Sous windows, les sections critiques sont exactement ce que je cherches: une solution de synchronisation broné au processus courant. Je me rappele avoir lu que les sections critiques était maintenant disponible sous linux. Avez vous des renseignements relatifs à cela ?

je ne sais ps quoi te répondre mais j´aimerais que tu m´en dise plus quant a la lourdeur des mutex (pthread_mutex).

et aussi, a quoi correspond "une solution de synchronisation broné au processus courant." (les moniteurs ?)

en java il y a des moniteurs maius je en suis pas sur qu´il y en ait dans linux. ?

Pour faire de la synchro entre plusieurs processus tu es obligé de repasser en espace noyau puisque deux processus partagent la meme ressource. Si c´est dans un seul processus, tu peux faire une gestion complete a l´echelle du processus et donc tu dois pouvoir le faire en user space. Et passer en kernelspace ca coute cher.

Ta question n´est pas très clair: les sections critiques ne sont pas une synchronisation entre thread. Est-ce néanmoins cela que tu veux reproduire ?

Si oui, je ne peut pas t´aider, mais si tu veux synchroniser des thread, tu peut le faire avec les signaux : sigwait, pthread_sigmask et pthread_kill peuvent t´y aider.

Par contre, je ne sais pas vraiment à quel niveau est-ce que ça se place (kernel ou pas).

pour aller dans le sens de dnoob700, si ce sont des processus legers (thread) que tu souhaite gerer, pas besoin de passer par shm, tu déclare un mutex (pthread_mutex) en variable globale et tout les thread lancé a partir du processus contenant le mutex y auront acces comme n´importe quelle autre variable gobale sans que ce dernier ne soit dupliqué ou autre; je ne pense pas que cela necesite l´intervention de mecanisme trop lourd du noyau.
ensuite tu régule l´acces au sections critique avec ce mutex (et eventuelement d´autres)

Je parlais de l´objet sectioncritique de windows.

Je ne vois pas comment monitorer l´acces a une variable a l´aide de signaux.

C´est déjà des mutex que j´utilise. Je me rappele de test que j´avais effectué sous windows. J´avais constaté une réelle différence de performance entre des mutex et des sectioncritique.

c´est rageant, j´était en cours de parallelisme il y a a peine 3 heures et on a fini de voir les moniteurs. Si j´avais su que c´était seulement (?) implémenté en java j´aurais demandé au prof ce qu´il en était pour le C...

sinon, un idée bete a laquelle tu as sans doute deja pensé : la glibc reprend pas mal de structures et autre algo de "base", regarde si il n´y a pas une implémentation de ce que tu cherches.

nan, justement ce n´était pas dans la libc.
C´est arrivé dans le kernel linux assez recement.

J´ai en outre trouvé les futexs. Ce n´est pas exactement ce que je cherche puisque ca reste inter-processus. Il semblerait que les mutex posix soit implémentés comme cela maintenant. Cela semble du fait assez rapide. A méditer.