un peu de voltige avec new

Version imprimable

14/04/2008, 10h40
screetch

un peu de voltige avec new

je cherche a inserer quelques infos lors de l'appel a l'operateur new en le mettant dans une macro. alors inserer le nom du fichier, ca je sais faire. je voudrais maintenant avoir un peu plus d'info (non, pas la ligne, ca aussi je sais faire!)

mon but serait de creer a la volée une instance statique de LocationInfo, qui contiendra le nom du fichier et la ligne, un pointeur sur un autre LocationInfo pour les mettre dans une liste chainée, et quelques valeurs de base (genre combien d'allocs ont ete realisées, etc). ainsi j'obtiens une liste chainée de tous les appels a new, avec le nombre d'appels, je peux verifier quel endroit alloue le plus, etc.

j'ai tout ce qu'il faut pour le faire sauf l'instance de LocationInfo que je n'arrive pas a créer a la volée.

par exemple j'aimerai que le code

Code:

int* a = _new int;

s'étende en

Code:

int* a = (static LocationInfo info(__FILE__, __LINE__, __FUNCTION__)), new(&info) int;

evidemment cela ne compile pas du tout, je cherche a le faire rentrer de force dans le compilateur!! (oui c'est pas malin :p)
je pense qu'il y a un moyen de conserver la syntaxe _new type; sinon l'autre possibilité est de faire
int* a;
_new(a, int);
mais ca ne me plait pas, je prefererais garder la "r-value" intacte.

j'ai pensé a :
- utiliser l'operateur ,
- mettre une boucle ou un truc du meme style;
- declarer une classe a cet endroit avec un champ statique
mais aucune de ces methodes n'autorise la declaration d'une variable a cet endroit :(

d'autres pistes ?
14/04/2008, 11h23
Kujara

Operateur << sur une classe, c'est beau :

Citation:

#define new MemoryManager::GetSingleton() << MemoryBlock( __FILE__, __FUNCTION__, __LINE__) << new

Et ça marche.
14/04/2008, 11h28
screetch

mais tu saurais rendre le memory block static ?

je voudrais creer un memory block par endroit ou on appelle new, pas par appel de new.

Je vois bien un truc de ce genre:

Code:

1
2
3
4
5
6
7
8
9
/* Doit être static, pour que chaque variable static n'appartienne qu') un seul source. */
template< int L >
static inline LocationInfo* MakeLocationInfo( std::string const &file, std::string const &function)
{
	static LocationInfo info(file, L, function);
	return &info;
}
 
#define _new new(MakeLocationInfo< __LINE__ >(__FILE__, __FUNCTION__))

Mais je n'ai pas testé, je ne sais même pas si ça compile.

14/04/2008, 11h58
screetch

et bien, ca alloue aussi :)
j'essaye quelques bidouilles avec vos propositions et je reviens

Citation:

Envoyé par screetch

je cherche a inserer quelques infos lors de l'appel a l'operateur new en le mettant dans une macro. alors inserer le nom du fichier, ca je sais faire. je voudrais maintenant avoir un peu plus d'info (non, pas la ligne, ca aussi je sais faire!)

mon but serait de creer a la volée une instance statique de LocationInfo, qui contiendra le nom du fichier et la ligne, un pointeur sur un autre LocationInfo pour les mettre dans une liste chainée, et quelques valeurs de base (genre combien d'allocs ont ete realisées, etc). ainsi j'obtiens une liste chainée de tous les appels a new, avec le nombre d'appels, je peux verifier quel endroit alloue le plus, etc.

j'ai tout ce qu'il faut pour le faire sauf l'instance de LocationInfo que je n'arrive pas a créer a la volée.

par exemple j'aimerai que le code

Code:

int* a = _new int;

s'étende en

Code:

int* a = (static LocationInfo info(__FILE__, __LINE__, __FUNCTION__)), new(&info) int;

Evidemment cela ne compile pas du tout, je cherche a le faire rentrer de force dans le compilateur!! (oui c'est pas malin :p)
je pense qu'il y a un moyen de conserver la syntaxe _new type; sinon l'autre possibilité est de faire
int* a;
_new(a, int);
mais ca ne me plait pas, je prefererais garder la "r-value" intacte.

j'ai pensé a :
- utiliser l'operateur ,
- mettre une boucle ou un truc du meme style;
- declarer une classe a cet endroit avec un champ statique
mais aucune de ces methodes n'autorise la declaration d'une variable a cet endroit :(

d'autres pistes ?

Il faut généralement définir un opérateur new global particulier. Il est déconseillé d'utiliser l'un des prototype suivant (mais pas interdit - c'est même spécifiquement autorisé, cf le standard §18.4.1) :
Code:

1 2 3 4 5 6 void* operator new(std::size_t size) throw(std::bad_alloc); void* operator new(std::size_t size, std::nothrow_t&) throw(); void* operator new[](std::size_t size) throw(std::bad_alloc); void* operator new[](std::size_t size, std::nothrow_t&) throw(); void* operator new(std::size_t size, void* ptr) throw(); void* operator new[](std::size_t size, void* ptr) throw();
Par exemple:
Code:

1 2 3 4 5 6 7 8 void operator new(std::size_t size, const LocationInfo& infos) throw(std::bad_alloc) { void *pointer = ::operator new(size); // ... return pointer; }
Tu peux ensuite utiliser le précompilateur pour cacher toute la magie de tes modifications :
Code:

1 2 #define MyNew new(LocationInfo(__FILE__, __LINE__, __FUNCTION__)) #define new MyNew
Cette dernière ligne prend avantage d'une particularité du précompilateur : l'expension de new en MyNew puis en new() casse le cycle d'expension des macros (donc new() n'est pas transformé en MyNew(), etc). La même technique est employée dans le MFC (cf. les fichiers C++ qui contiennent la définition #define new DebugNew). Cela te permet d'avoir le même code, que ton opérateur soit utilisé ou non.

Le code suivant devrait alors fonctionner comme tu le souhaites:

Code:

int* i = new int;

Le fait de passer LocationInfo par un pointeur n'est pas nécessairement une bonne idée (puisque cela oblige la variable à être statique; hors, tu n'as pas de contrôle véritable sur l'ordre de destruction des variables statiques, donc tu ne peux pas t'assurer que celles-ci existeront toujours une fois sorti de la fonction main() - là ou normalement, tu devrais vérifier si tu as des memory leaks). Il est préférable de copier les informations dans un objet dont tu maitrise la durée de vie.

Attention aussi à ne pas faire d'allocations dans LocationInfos (pour des raisons évidente de récursivité).

Pour plus d'information: cf le standard §18.4.1, §3.7.3.

14/04/2008, 12h18
Emmanuel Deloget

Citation:

Envoyé par screetch

mais tu saurais rendre le memory block static ?

je voudrais creer un memory block par endroit ou on appelle new, pas par appel de new.

Si tu stockes ensuite les blocks dans un std::set<LocationInfos, ptr>, tu peux t'assurer de leur unicité (ne pas oublier de définir les opérateurs nécessaires sur LocationInfos).

Sinon, c'est quoi l'intérêt d'avoir les LocationInfos statiques ?
14/04/2008, 12h23
screetch
wi alors voila, c'est presque ca (ca ressemble enormement au code que j'ai)

a noter que definir new ce n'est pas forcément une bonne idée car alors quand on redefinit new dans une classe le compilateur se plaint. ce n'est pas un probleme pour moi, nous utilisons deja une macro _new qui remappe a l'heure actuelle sur new sans rien changer.

mais maintenant j'aimerai que la LocationInfo soit statique, c'est a dire partagée par tous les "new" qui seront appelé de la.

exemple :
Code:

1 2 3 4 5 6 7 8 9 10 void test() { int* a = _new int; } int main() { test(); test(); LocationInfo::printStats(); }
je voudrais que printStats, sans faire aucun calcul (de preference), me reponde :

Code:

main.cpp:3 : 2 calls to new

vos propositions montreraient quelque chose du genre :
Code:

1 2 main.cpp:3 : 1 call to new main.cpp:3 : 1 call to new
voyez vous mon probleme ?
14/04/2008, 12h25
screetch

autre avantage d'avoir les LocationInfo statiques : ils existent apres l'appel a la fonction. important pour des stats d'appels de new : par exemple, par frame on a appelé 1800 fois "new" depuis cette ligne dans le fichier : houlala!

de plus on peut detecter les leaks a l'execution : ce LocationInfo voit son compteur augmenter chaque frame : hop on a le fichier et la ligne du new.
14/04/2008, 13h39
screetch

la version de medinoc marche presque :)

on a juste un dernier probleme : on utilise des fichiers "master" pour accelerer la compilation, et du coup la fonction est commune a une 20aine de fichier. j'ai la parade, je poste la version complete cet aprem =)

merci pour l'aide
14/04/2008, 14h40
Emmanuel Deloget

Citation:

Envoyé par screetch

autre avantage d'avoir les LocationInfo statiques : ils existent apres l'appel a la fonction. important pour des stats d'appels de new : par exemple, par frame on a appelé 1800 fois "new" depuis cette ligne dans le fichier : houlala!

de plus on peut detecter les leaks a l'execution : ce LocationInfo voit son compteur augmenter chaque frame : hop on a le fichier et la ligne du new.

Oui, mais vu qu'ils sont détruits dans l'ordre inverse de la complétion de leur constructeurs, tu ne peux pas être sûr de leur existence dès lors que tu quittes la fonction main(). Mais c'est bien souvent en dehors de main() qu'on souhaite voir si il existe encore des leaks. Ceci dit, pour faire de l'analyse frame à frame, ça ne pose pas de problèmes.

non en fait je me suis trompé, je pensais avoir resolu mon probleme de master mais en fait non :(

en gros je pensais donner un deuxieme argument de template; chaque fois que le fichier .h est inclus, un compteur est incrementé et ce compteur est donné en second argument de template. donc on genere une nouvelle fonction non pas par fichier mais par inclusion du fichier en-tete.

en gros :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 #ifndef COUNTER # define COUNTER 0 #else # inc(COUNTER) #endif #ifndef INCLUDED_FILE_H_ # define INCLUDED_FILE_H_ /* Doit être static, pour que chaque variable static n'appartienne qu') un seul source. */ template< int L, int F > static inline LocationInfo* MakeLocationInfo( std::string const &file, std::string const &function) { static LocationInfo info(file, L, function); return &info; } #define _new new(MakeLocationInfo<__LINE__,COUNTER>(__FILE__,__LINE__,__FUNCTION__)) #endif
le probleme c'est incrementer le compteur :(

14/04/2008, 14h48
screetch

Citation:

Envoyé par Emmanuel Deloget

Oui, mais vu qu'ils sont détruits dans l'ordre inverse de la complétion de leur constructeurs, tu ne peux pas être sûr de leur existence dès lors que tu quittes la fonction main(). Mais c'est bien souvent en dehors de main() qu'on souhaite voir si il existe encore des leaks. Ceci dit, pour faire de l'analyse frame à frame, ça ne pose pas de problèmes.

je suis d'accord que c'est souvent apres main que l'on a besoin des leaks mais j'ai aussi besoin de statistiques tres poussées sur les new :
- qui alloue (quel fichier/ligne)
- combien de fois par frame
- quelle quantité (taille, pas nombre d'appels)
- conbien d'allocs encore en vie

ces stats seraient ensuite affichées a l'ecran. On pourrait les trier par fichier pour voir toute les allocs dans ce fichier (ou repertoire), on peut aussi les trier åar nombre d'allocs, on peut enfin mettre un "watch" sur des allocs qui grossissent sans jamais maigrir. Tout cela, au runtime et non pas a la fin de l'execution

nous avons deja beaucoup de statistiques sur la memoire mais on peut en savoir beaucoup plus =)

voila je poste mon avancée sur ce sujet, c'est pas vraiment complet mais c'est un bon point de depart =)

alloc.h:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
#ifndef ALLOC_H_
#define ALLOC_H_
 
#include <cstdio>
#include <new>
 
class LocationInfo
{
public:
	LocationInfo(const char* file, int line, const char* function);
	~LocationInfo();
	static void printStats();
	int allocCount;
	int aliveCount;
private:
	const char *file;
	int line;
	const char *function;
	LocationInfo* prev;
	LocationInfo* next;
};
 
 
 
void* _alloc(size_t size, LocationInfo& info);
void  _free(void* ptr);
 
 
inline void* operator new(size_t size, LocationInfo& from)
{
	return _alloc(size, from);
}
 
// a delete operator must exist with the same signature
// it is called in case an exception is thrown in the
// constructor
inline void operator delete(void* mem, LocationInfo& from)
{
	return _free(mem);
}
 
inline void operator delete(void* mem)
{
	return _free(mem);
}
 
 
template< int MY_LINE >
static inline LocationInfo& BuildInfoName(const char* file, int line, const char* function)
{
	static LocationInfo where(file,line,function);
	return where;
}
 
#define _new	new( BuildInfoName<__LINE__>(__FILE__,__LINE__,__FUNCTION__) )
 
#endif

alloc.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
#include "alloc.h"
#include <malloc.h>
 
static LocationInfo* s_root = 0;
 
void* _alloc(size_t size, LocationInfo& info)
{
	void* mem = malloc(size+sizeof(LocationInfo*));
	*(LocationInfo**)mem = &info;
	info.allocCount++;
	info.aliveCount++;
	return (char*) mem + 4;
}
 
void _free(void* mem)
{
	void* realmem = (char*)mem - sizeof(LocationInfo*);
	(*(LocationInfo**)realmem)->aliveCount--;
	free(realmem);
}
 
LocationInfo::LocationInfo(const char *file, int line, const char *function)
	:	file(file)
	,	line(line)
	,	function(function)
	,	allocCount(0)
	,	prev(0)
	,	next(s_root)
{
	s_root = this;
}
 
LocationInfo::~LocationInfo()
{
	if(prev)
	{
		prev->next = next;
	}
	else
	{
		s_root = next;
	}
	if(next)
	{
		next->prev = prev;
	}
	prev = 0;
	next = 0;
}
 
void LocationInfo::printStats()
{
	LocationInfo* info = s_root;
	while(info)
	{
		printf("alloc(%d/%d) %s:%d (%s)\n", info->aliveCount, info->allocCount, info->file, info->line, info->function);
		info = info->next;
	}
}

petit programme de test

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include "alloc.h"
#include <cstdlib>
 
int* test(bool btoo)
{
	int* a = _new int;
	if(btoo)
	{
		int* b = _new int;
		// boooh bad leak
		//delete b;
	}
	return a;
}
 
int main(int arcg, char *argv[])
{
	int* a = test(true);
	int* b = test(false);
	delete b;
	delete a;
	LocationInfo::printStats();
	return EXIT_SUCCESS;
}

le programme de test vous montrera les deux endroits d'ou on a alloué, ainsi que le nombre d'allocs de chaque type toujours en vie a la fin du programme.

c'est pas complet mais ca marche plutot pas mal :)

15/04/2008, 14h11
Emmanuel Deloget

Citation:

Envoyé par screetch

le probleme c'est incrementer le compteur :(

Si tu est sous VC++, tu peux utiliser __COUNTER__, qui est incrémenté tout seul.