J'ai un programme resident style serveur TCP que je laisse tourner sur des
machines. Le process prend environ 8MB RAM (+ ou - autant Windows/Unix);
jusque là rien de bien mechant sauf que j'ai noté qu'au bout de quelques
temps (plusieures heures), le process ne prend plus que ... 4 MB RAM.
Comme j'aimerais que le programme prenne le minimum de ressources, je me
demande ce qui pourrait bien expliquer ce changement, et surtout comment
le programmer avec des timers plus courts.
4 MB de gain c'est pas terrible, mais lorsque le process est sollicité,
il monte à 30 MB (lancement de threads etc...); d'où le probleme...
Quelque'un connait-il les mecanismes intrinseques de PERL (ex. garbage
collector) et d'eventuels moyens de les controler?
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
dominix
Daniel Cohen wrote:
J'ai un programme resident style serveur TCP que je laisse tourner sur des machines. Le process prend environ 8MB RAM (+ ou - autant Windows/Unix); jusque là rien de bien mechant sauf que j'ai noté qu'au bout de quelques temps (plusieures heures), le process ne prend plus que ... 4 MB RAM.
Comme j'aimerais que le programme prenne le minimum de ressources, je me demande ce qui pourrait bien expliquer ce changement, et surtout comment le programmer avec des timers plus courts.
4 MB de gain c'est pas terrible, mais lorsque le process est sollicité, il monte à 30 MB (lancement de threads etc...); d'où le probleme...
sur quel modeles cela est il construit ? fork ? threads ? ...
Socket ? IO::Socket ? Raw::Ip ? :-)) quel systeme d'exploitation ? quel modules utilisé ? Memoize ?? Cache::* ??? pourrais tu donner un skelette exemple de l'appli. (boucle principale, ... )
Quelque'un connait-il les mecanismes intrinseques de PERL (ex. garbage collector) et d'eventuels moyens de les controler?
j'ai pas cette pretention mais je pourrais peut etre voir la poutre ....
-- dominix
Daniel Cohen wrote:
J'ai un programme resident style serveur TCP que je laisse tourner
sur des machines. Le process prend environ 8MB RAM (+ ou - autant
Windows/Unix); jusque là rien de bien mechant sauf que j'ai noté
qu'au bout de quelques temps (plusieures heures), le process ne prend
plus que ... 4 MB RAM.
Comme j'aimerais que le programme prenne le minimum de ressources, je
me demande ce qui pourrait bien expliquer ce changement, et surtout
comment le programmer avec des timers plus courts.
4 MB de gain c'est pas terrible, mais lorsque le process est
sollicité, il monte à 30 MB (lancement de threads etc...); d'où le
probleme...
sur quel modeles cela est il construit ? fork ? threads ? ...
Socket ? IO::Socket ? Raw::Ip ? :-))
quel systeme d'exploitation ?
quel modules utilisé ? Memoize ?? Cache::* ???
pourrais tu donner un skelette exemple de l'appli.
(boucle principale, ... )
Quelque'un connait-il les mecanismes intrinseques de PERL (ex. garbage
collector) et d'eventuels moyens de les controler?
j'ai pas cette pretention mais je pourrais peut etre voir la poutre ....
J'ai un programme resident style serveur TCP que je laisse tourner sur des machines. Le process prend environ 8MB RAM (+ ou - autant Windows/Unix); jusque là rien de bien mechant sauf que j'ai noté qu'au bout de quelques temps (plusieures heures), le process ne prend plus que ... 4 MB RAM.
Comme j'aimerais que le programme prenne le minimum de ressources, je me demande ce qui pourrait bien expliquer ce changement, et surtout comment le programmer avec des timers plus courts.
4 MB de gain c'est pas terrible, mais lorsque le process est sollicité, il monte à 30 MB (lancement de threads etc...); d'où le probleme...
sur quel modeles cela est il construit ? fork ? threads ? ...
Socket ? IO::Socket ? Raw::Ip ? :-)) quel systeme d'exploitation ? quel modules utilisé ? Memoize ?? Cache::* ??? pourrais tu donner un skelette exemple de l'appli. (boucle principale, ... )
Quelque'un connait-il les mecanismes intrinseques de PERL (ex. garbage collector) et d'eventuels moyens de les controler?
j'ai pas cette pretention mais je pourrais peut etre voir la poutre ....
-- dominix
Daniel
On Tue, 24 Feb 2004 14:07:25 -1000, dominix wrote:
sur quel modeles cela est il construit ? fork ? threads ? ... Socket ? IO::Socket ? Raw::Ip ? :-)) quel systeme d'exploitation ? quel modules utilisé ? Memoize ?? Cache::* ??? pourrais tu donner un skelette exemple de l'appli. (boucle principale, .
C'est construit sur la base d'un IO::Socket::INET() qui lance les threads par fork() lors de connexion. J'ai 8MB avec le parent seulement. J'ai essayé un modele pre-fork childs à base de fork() afin d'ameliorer les temps de reponse (lenteur du fork()) Communications entre parent et fils grace à un socketpair()
Meme resultat sur Win32, Linux et SunOS. Le mieux que j'ai pu faire, c'est d'utiliser l'autoloader et de charger les modules et functions le plus tard possible.
En fait c'est pas la consommation instantanée (cad lorsque le serveur est sollicité) qui m'importe; c'est lorsqu'il est en attente, afin que les modules non utilisés soient "dechargés" rapidement.
J'ai lu la doc perl sur la comparaison fork() et thread. As tu une experience comparative entre les 2?
Sais-tu comment controler le chargement/dechargement dynamique de modules. Merci
On Tue, 24 Feb 2004 14:07:25 -1000, dominix wrote:
sur quel modeles cela est il construit ? fork ? threads ? ...
Socket ? IO::Socket ? Raw::Ip ? :-))
quel systeme d'exploitation ?
quel modules utilisé ? Memoize ?? Cache::* ???
pourrais tu donner un skelette exemple de l'appli.
(boucle principale, .
C'est construit sur la base d'un IO::Socket::INET() qui lance
les threads par fork() lors de connexion. J'ai 8MB avec le parent
seulement. J'ai essayé un modele pre-fork childs à base de fork()
afin d'ameliorer les temps de reponse (lenteur du fork())
Communications entre parent et fils grace à un socketpair()
Meme resultat sur Win32, Linux et SunOS. Le mieux que j'ai pu faire,
c'est d'utiliser l'autoloader et de charger les modules et functions le
plus tard possible.
En fait c'est pas la consommation instantanée (cad lorsque le serveur
est sollicité) qui m'importe; c'est lorsqu'il est en attente, afin
que les modules non utilisés soient "dechargés" rapidement.
J'ai lu la doc perl sur la comparaison fork() et thread. As tu une
experience comparative entre les 2?
Sais-tu comment controler le chargement/dechargement dynamique de modules.
Merci
On Tue, 24 Feb 2004 14:07:25 -1000, dominix wrote:
sur quel modeles cela est il construit ? fork ? threads ? ... Socket ? IO::Socket ? Raw::Ip ? :-)) quel systeme d'exploitation ? quel modules utilisé ? Memoize ?? Cache::* ??? pourrais tu donner un skelette exemple de l'appli. (boucle principale, .
C'est construit sur la base d'un IO::Socket::INET() qui lance les threads par fork() lors de connexion. J'ai 8MB avec le parent seulement. J'ai essayé un modele pre-fork childs à base de fork() afin d'ameliorer les temps de reponse (lenteur du fork()) Communications entre parent et fils grace à un socketpair()
Meme resultat sur Win32, Linux et SunOS. Le mieux que j'ai pu faire, c'est d'utiliser l'autoloader et de charger les modules et functions le plus tard possible.
En fait c'est pas la consommation instantanée (cad lorsque le serveur est sollicité) qui m'importe; c'est lorsqu'il est en attente, afin que les modules non utilisés soient "dechargés" rapidement.
J'ai lu la doc perl sur la comparaison fork() et thread. As tu une experience comparative entre les 2?
Sais-tu comment controler le chargement/dechargement dynamique de modules. Merci
dominix
Daniel wrote:
On Tue, 24 Feb 2004 14:07:25 -1000, dominix wrote:
sur quel modeles cela est il construit ? fork ? threads ? ... Socket ? IO::Socket ? Raw::Ip ? :-)) quel systeme d'exploitation ? quel modules utilisé ? Memoize ?? Cache::* ??? pourrais tu donner un skelette exemple de l'appli. (boucle principale, .
C'est construit sur la base d'un IO::Socket::INET() qui lance les threads par fork() lors de connexion. J'ai 8MB avec le parent seulement. J'ai essayé un modele pre-fork childs à base de fork() afin d'ameliorer les temps de reponse (lenteur du fork()) Communications entre parent et fils grace à un socketpair()
Meme resultat sur Win32, Linux et SunOS. Le mieux que j'ai pu faire, c'est d'utiliser l'autoloader et de charger les modules et functions le plus tard possible.
En fait c'est pas la consommation instantanée (cad lorsque le serveur est sollicité) qui m'importe; c'est lorsqu'il est en attente, afin que les modules non utilisés soient "dechargés" rapidement.
J'ai lu la doc perl sur la comparaison fork() et thread. As tu une experience comparative entre les 2?
Sais-tu comment controler le chargement/dechargement dynamique de modules. Merci
ce que je fait dans ce cas, c'est de laisser le contrôle au parent et de loader les modules supplementaire apres le fork (avec require) et de faire mourrir le child lorsque la transaction est terminé. En terminant ainsi le menage est total, l'inconvenient est au niveau de la performance lorsque beaucoup de connections sont misent en jeu, il faut alors pre-forker ce qui fait perdre un peu de son interet a la methode. il est a mon avis assez compliqué de combiner le re-use de la connection et la gestion de la memoire. c'est un choix qu'il faut faire assez tôt dans le design. Si tu veux simplement decharger un module (pas simple en fait) il y a un moyen avec Symbol::delete_package cf perldoc Symbol ou bien utiliser Safe::World ou Safe.pm (que je connais pas suffisament). Je sais que Symbol fait le menage mais je ne suis pas sur que cela decharge vraiment/correctement les Shared Objects (.so ou .dll).
-- dominix
Daniel wrote:
On Tue, 24 Feb 2004 14:07:25 -1000, dominix wrote:
sur quel modeles cela est il construit ? fork ? threads ? ...
Socket ? IO::Socket ? Raw::Ip ? :-))
quel systeme d'exploitation ?
quel modules utilisé ? Memoize ?? Cache::* ???
pourrais tu donner un skelette exemple de l'appli.
(boucle principale, .
C'est construit sur la base d'un IO::Socket::INET() qui lance
les threads par fork() lors de connexion. J'ai 8MB avec le parent
seulement. J'ai essayé un modele pre-fork childs à base de fork()
afin d'ameliorer les temps de reponse (lenteur du fork())
Communications entre parent et fils grace à un socketpair()
Meme resultat sur Win32, Linux et SunOS. Le mieux que j'ai pu faire,
c'est d'utiliser l'autoloader et de charger les modules et functions
le plus tard possible.
En fait c'est pas la consommation instantanée (cad lorsque le serveur
est sollicité) qui m'importe; c'est lorsqu'il est en attente, afin
que les modules non utilisés soient "dechargés" rapidement.
J'ai lu la doc perl sur la comparaison fork() et thread. As tu une
experience comparative entre les 2?
Sais-tu comment controler le chargement/dechargement dynamique de
modules. Merci
ce que je fait dans ce cas, c'est de laisser le contrôle au parent et de
loader les modules supplementaire apres le fork (avec require) et de faire
mourrir le child lorsque la transaction est terminé.
En terminant ainsi le menage est total, l'inconvenient est au niveau de la
performance lorsque beaucoup de connections sont misent en jeu, il faut
alors pre-forker ce qui fait perdre un peu de son interet a la methode. il
est a mon avis assez compliqué de combiner le re-use de la connection et la
gestion de la memoire. c'est un choix qu'il faut faire assez tôt dans le
design. Si tu veux simplement decharger un module (pas simple en fait) il y
a un moyen avec Symbol::delete_package cf perldoc Symbol ou bien utiliser
Safe::World ou Safe.pm (que je connais pas suffisament). Je sais que Symbol
fait le menage mais je ne suis pas sur que cela decharge
vraiment/correctement les Shared Objects (.so ou .dll).
On Tue, 24 Feb 2004 14:07:25 -1000, dominix wrote:
sur quel modeles cela est il construit ? fork ? threads ? ... Socket ? IO::Socket ? Raw::Ip ? :-)) quel systeme d'exploitation ? quel modules utilisé ? Memoize ?? Cache::* ??? pourrais tu donner un skelette exemple de l'appli. (boucle principale, .
C'est construit sur la base d'un IO::Socket::INET() qui lance les threads par fork() lors de connexion. J'ai 8MB avec le parent seulement. J'ai essayé un modele pre-fork childs à base de fork() afin d'ameliorer les temps de reponse (lenteur du fork()) Communications entre parent et fils grace à un socketpair()
Meme resultat sur Win32, Linux et SunOS. Le mieux que j'ai pu faire, c'est d'utiliser l'autoloader et de charger les modules et functions le plus tard possible.
En fait c'est pas la consommation instantanée (cad lorsque le serveur est sollicité) qui m'importe; c'est lorsqu'il est en attente, afin que les modules non utilisés soient "dechargés" rapidement.
J'ai lu la doc perl sur la comparaison fork() et thread. As tu une experience comparative entre les 2?
Sais-tu comment controler le chargement/dechargement dynamique de modules. Merci
ce que je fait dans ce cas, c'est de laisser le contrôle au parent et de loader les modules supplementaire apres le fork (avec require) et de faire mourrir le child lorsque la transaction est terminé. En terminant ainsi le menage est total, l'inconvenient est au niveau de la performance lorsque beaucoup de connections sont misent en jeu, il faut alors pre-forker ce qui fait perdre un peu de son interet a la methode. il est a mon avis assez compliqué de combiner le re-use de la connection et la gestion de la memoire. c'est un choix qu'il faut faire assez tôt dans le design. Si tu veux simplement decharger un module (pas simple en fait) il y a un moyen avec Symbol::delete_package cf perldoc Symbol ou bien utiliser Safe::World ou Safe.pm (que je connais pas suffisament). Je sais que Symbol fait le menage mais je ne suis pas sur que cela decharge vraiment/correctement les Shared Objects (.so ou .dll).
