Il parait que fork est aussi rapide que spawn sous linux ...
je ne comprends pas tellement puisque fork est censé recopier
tout l'environnement data du processus parent. En plus
je ne trouve pas la commande spawn !
Je veux bien utiliser fork. Mais quand le processus fils termine
je le tue avec un exit(0) et cet exit(0) déclenche les destructeurs
de mes classes qui détruisent par un socket des objets qu'il ne
faut pas détruire ...
Il me semble que je serais plus à l'aise en lancant un thread. Non ?
Comment lance t-on un thread sous linux ?
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
Nicolas George
"Eric Bart" wrote in message <410fc350$0$24058$:
Il parait que fork est aussi rapide que spawn sous linux ... je ne comprends pas tellement puisque fork est censé recopier tout l'environnement data du processus parent.
La plupart des OS modernes utilisent le copy-on-write pour ça : les plages mémoires à copier sont marquées dans la MMU comme read-only, partagées entre les deux process, et à la première tentative de modification, le noyau profite de la faute de page pour faire la copie. Seules les pages réellement modifiées sont ainsi copiées, et uniquement au moment où elles le sont.
En plus je ne trouve pas la commande spawn !
C'est normal, ça n'existe pas. La dernière fois que j'ai entendu parler de spawn, c'était sous DOS, où ça correspondait à un fork+exec+wait (évidemment, sous un (ahem) OS monotâche, pas de fork sans wait...), si je me souviens bien.
Je veux bien utiliser fork. Mais quand le processus fils termine je le tue avec un exit(0) et cet exit(0) déclenche les destructeurs de mes classes qui détruisent par un socket des objets qu'il ne faut pas détruire ...
La commande _exit sert à ça, mais je trouve ça assez moche. En général, j'aurais tendance à dire que si l'objet ne peut pas être détruit sans qu'il endommage une resource potentiellement partagée, c'est que son API est mal conçue.
Il me semble que je serais plus à l'aise en lancant un thread. Non ?
Ça dépend énormément du contexte.
Comment lance t-on un thread sous linux ?
Comme partout, pthread_create.
"Eric Bart" wrote in message <410fc350$0$24058$626a14ce@news.free.fr>:
Il parait que fork est aussi rapide que spawn sous linux ...
je ne comprends pas tellement puisque fork est censé recopier
tout l'environnement data du processus parent.
La plupart des OS modernes utilisent le copy-on-write pour ça : les
plages mémoires à copier sont marquées dans la MMU comme read-only,
partagées entre les deux process, et à la première tentative de
modification, le noyau profite de la faute de page pour faire la copie.
Seules les pages réellement modifiées sont ainsi copiées, et uniquement
au moment où elles le sont.
En plus
je ne trouve pas la commande spawn !
C'est normal, ça n'existe pas. La dernière fois que j'ai entendu parler
de spawn, c'était sous DOS, où ça correspondait à un fork+exec+wait
(évidemment, sous un (ahem) OS monotâche, pas de fork sans wait...), si
je me souviens bien.
Je veux bien utiliser fork. Mais quand le processus fils termine
je le tue avec un exit(0) et cet exit(0) déclenche les destructeurs
de mes classes qui détruisent par un socket des objets qu'il ne
faut pas détruire ...
La commande _exit sert à ça, mais je trouve ça assez moche. En général,
j'aurais tendance à dire que si l'objet ne peut pas être détruit sans
qu'il endommage une resource potentiellement partagée, c'est que son API
est mal conçue.
Il me semble que je serais plus à l'aise en lancant un thread. Non ?
Il parait que fork est aussi rapide que spawn sous linux ... je ne comprends pas tellement puisque fork est censé recopier tout l'environnement data du processus parent.
La plupart des OS modernes utilisent le copy-on-write pour ça : les plages mémoires à copier sont marquées dans la MMU comme read-only, partagées entre les deux process, et à la première tentative de modification, le noyau profite de la faute de page pour faire la copie. Seules les pages réellement modifiées sont ainsi copiées, et uniquement au moment où elles le sont.
En plus je ne trouve pas la commande spawn !
C'est normal, ça n'existe pas. La dernière fois que j'ai entendu parler de spawn, c'était sous DOS, où ça correspondait à un fork+exec+wait (évidemment, sous un (ahem) OS monotâche, pas de fork sans wait...), si je me souviens bien.
Je veux bien utiliser fork. Mais quand le processus fils termine je le tue avec un exit(0) et cet exit(0) déclenche les destructeurs de mes classes qui détruisent par un socket des objets qu'il ne faut pas détruire ...
La commande _exit sert à ça, mais je trouve ça assez moche. En général, j'aurais tendance à dire que si l'objet ne peut pas être détruit sans qu'il endommage une resource potentiellement partagée, c'est que son API est mal conçue.
Il me semble que je serais plus à l'aise en lancant un thread. Non ?
Ça dépend énormément du contexte.
Comment lance t-on un thread sous linux ?
Comme partout, pthread_create.
Eric Bart
Oui Merci
Finalement le fork me parait très bien et _exit marche bien !
Oui Merci
Finalement le fork me parait très bien et _exit marche bien !
Finalement le fork me parait très bien et _exit marche bien !
Pierre Thorel
Oui Merci
Finalement le fork me parait très bien et _exit marche bien !
Les threads, c'est quand même plus propre et plus léger (l'espace d'adressage mémoire est partagé, ce qui signifie que tous les threads d'un même processus travaillent sur une même copie des données).
L'inconvénient, c'est qu'il faut faire attention à ce que les différents threads n'entrent pas en concurrence lorsqu'ils accèdent aux données en mémoire.
Pour l'utilisation, ce n'est pas très dur. Un bon coup de man pthread_create permet de s'en convaincre ! Pour règler les problèmes de concurrence, regarder les fonctions pthread_mutex_{init,lock,unlock}.
Cordialement, Pierre Thorel
Oui Merci
Finalement le fork me parait très bien et _exit marche bien !
Les threads, c'est quand même plus propre et plus léger (l'espace
d'adressage mémoire est partagé, ce qui signifie que tous les threads d'un
même processus travaillent sur une même copie des données).
L'inconvénient, c'est qu'il faut faire attention à ce que les différents
threads n'entrent pas en concurrence lorsqu'ils accèdent aux données en
mémoire.
Pour l'utilisation, ce n'est pas très dur. Un bon coup de man
pthread_create permet de s'en convaincre !
Pour règler les problèmes de concurrence, regarder les fonctions
pthread_mutex_{init,lock,unlock}.
Finalement le fork me parait très bien et _exit marche bien !
Les threads, c'est quand même plus propre et plus léger (l'espace d'adressage mémoire est partagé, ce qui signifie que tous les threads d'un même processus travaillent sur une même copie des données).
L'inconvénient, c'est qu'il faut faire attention à ce que les différents threads n'entrent pas en concurrence lorsqu'ils accèdent aux données en mémoire.
Pour l'utilisation, ce n'est pas très dur. Un bon coup de man pthread_create permet de s'en convaincre ! Pour règler les problèmes de concurrence, regarder les fonctions pthread_mutex_{init,lock,unlock}.
