Bonjour,
étant potentiellement confronté à un problème de mémoire insuffisante en cas
d'utilisation des opérateurs new et delete,
j'ai dans l'idée de redéfinir des opérateurs New et Delete (implémentés
comme fonctions membres static pour certaines classes), qui seraient
attachés à des blocs de mémoire éventuellement réservés sur le disque (en
dernier recours).
(nota : je préfère ne pas redéfinir les opérateurs new et delete => à moi de
faire attention)
Avez-vous déjà fait cela et si oui, avez-vous des liens vers des exemples ?
Merci à vous.
Marc
si j'ai beaucoup de petits objets, je les mets tous dans un vector<>, qui s'occupe d'allouer un bloc contigu, donc une seule allocation, et pas de fragmentation.
Récemment (et en c#, mais je pense que la leçon doit pas mal s'appliquer au c++ aussi), ayant un cas de ce genre et imaginant que j'allais être tué par l'overhead d'allocation, j'ai écrit tout un code compliqué pour faire cela, et allouer tout en une fois un bloc contigu. Qui plus est avec la fonction système d'allocation mémoire, pas celle de c# (pour cela que le code était complexe d'ailleurs).
C'est là que j'ai découvert que j'allouais au max un tiers de ma ram disponible dans ce bloc contigu. Ça doit être un effet du c# et nettement moins pire en c++, mais je ne serais pas surpris que le même problème se produise en partie.
C'est là que j'ai réfléchi un peu mieux, réalisé que si je sérialisais l'objet il prenait quand même un bloc d'1K ou 2K (plus une chaîne d'identifiant), et donc que l'overhead par objet n'était pas si significatif que cela. J'ai viré mon code compliqué (sauf la partie sérialisation de l'objet pour qu'il n'utilise qu'un seul bloc mémoire contigu), utilisé un vecteur de pointeurs vers mes objets, et réussi à utiliser efficacement la presque intégralité de de ma mémoire.
Bref, maintenant je sais qu'il ne faut pas sauter sur l'idée d'allouer tout en un seul bloc. Et même si j'ai beaucoup d'objets réellement petits, la prochaine fois je commencerais probablement par me poser la question d'en agglomérer des blocs de 5 à 10 pour que l'overhead d'allocation ne soit pas significatif, mais toujours ne pas chercher à allouer en un bloc.
Fabien LE LEZ wrote:
si j'ai beaucoup de petits objets, je les mets tous dans un
vector<>, qui s'occupe d'allouer un bloc contigu, donc une seule
allocation, et pas de fragmentation.
Récemment (et en c#, mais je pense que la leçon doit pas mal s'appliquer
au c++ aussi), ayant un cas de ce genre et imaginant que j'allais être
tué par l'overhead d'allocation, j'ai écrit tout un code compliqué pour
faire cela, et allouer tout en une fois un bloc contigu.
Qui plus est avec la fonction système d'allocation mémoire, pas celle de
c# (pour cela que le code était complexe d'ailleurs).
C'est là que j'ai découvert que j'allouais au max un tiers de ma ram
disponible dans ce bloc contigu. Ça doit être un effet du c# et
nettement moins pire en c++, mais je ne serais pas surpris que le même
problème se produise en partie.
C'est là que j'ai réfléchi un peu mieux, réalisé que si je sérialisais
l'objet il prenait quand même un bloc d'1K ou 2K (plus une chaîne
d'identifiant), et donc que l'overhead par objet n'était pas si
significatif que cela. J'ai viré mon code compliqué (sauf la partie
sérialisation de l'objet pour qu'il n'utilise qu'un seul bloc mémoire
contigu), utilisé un vecteur de pointeurs vers mes objets, et réussi à
utiliser efficacement la presque intégralité de de ma mémoire.
Bref, maintenant je sais qu'il ne faut pas sauter sur l'idée d'allouer
tout en un seul bloc. Et même si j'ai beaucoup d'objets réellement
petits, la prochaine fois je commencerais probablement par me poser la
question d'en agglomérer des blocs de 5 à 10 pour que l'overhead
d'allocation ne soit pas significatif, mais toujours ne pas chercher à
allouer en un bloc.
si j'ai beaucoup de petits objets, je les mets tous dans un vector<>, qui s'occupe d'allouer un bloc contigu, donc une seule allocation, et pas de fragmentation.
Récemment (et en c#, mais je pense que la leçon doit pas mal s'appliquer au c++ aussi), ayant un cas de ce genre et imaginant que j'allais être tué par l'overhead d'allocation, j'ai écrit tout un code compliqué pour faire cela, et allouer tout en une fois un bloc contigu. Qui plus est avec la fonction système d'allocation mémoire, pas celle de c# (pour cela que le code était complexe d'ailleurs).
C'est là que j'ai découvert que j'allouais au max un tiers de ma ram disponible dans ce bloc contigu. Ça doit être un effet du c# et nettement moins pire en c++, mais je ne serais pas surpris que le même problème se produise en partie.
C'est là que j'ai réfléchi un peu mieux, réalisé que si je sérialisais l'objet il prenait quand même un bloc d'1K ou 2K (plus une chaîne d'identifiant), et donc que l'overhead par objet n'était pas si significatif que cela. J'ai viré mon code compliqué (sauf la partie sérialisation de l'objet pour qu'il n'utilise qu'un seul bloc mémoire contigu), utilisé un vecteur de pointeurs vers mes objets, et réussi à utiliser efficacement la presque intégralité de de ma mémoire.
Bref, maintenant je sais qu'il ne faut pas sauter sur l'idée d'allouer tout en un seul bloc. Et même si j'ai beaucoup d'objets réellement petits, la prochaine fois je commencerais probablement par me poser la question d'en agglomérer des blocs de 5 à 10 pour que l'overhead d'allocation ne soit pas significatif, mais toujours ne pas chercher à allouer en un bloc.
Fabien LE LEZ
On Fri, 12 Mar 2010 18:19:00 +0100, Jean-Marc Desperrier :
Bref, maintenant je sais qu'il ne faut pas sauter sur l'idée d'allouer tout en un seul bloc.
Le cas du C++ est différent : le type "tableau" par défaut (i.e. qu'on choisit quand on n'a pas de besoins spéciaux) est std::vector<>. Ainsi, stocker les éléments d'un tableau dans un seul bloc est la solution la plus simple.
On Fri, 12 Mar 2010 18:19:00 +0100, Jean-Marc Desperrier
<jmdesp@gmail.com>:
Bref, maintenant je sais qu'il ne faut pas sauter sur l'idée d'allouer
tout en un seul bloc.
Le cas du C++ est différent : le type "tableau" par défaut (i.e. qu'on
choisit quand on n'a pas de besoins spéciaux) est std::vector<>.
Ainsi, stocker les éléments d'un tableau dans un seul bloc est la
solution la plus simple.
On Fri, 12 Mar 2010 18:19:00 +0100, Jean-Marc Desperrier :
Bref, maintenant je sais qu'il ne faut pas sauter sur l'idée d'allouer tout en un seul bloc.
Le cas du C++ est différent : le type "tableau" par défaut (i.e. qu'on choisit quand on n'a pas de besoins spéciaux) est std::vector<>. Ainsi, stocker les éléments d'un tableau dans un seul bloc est la solution la plus simple.
