Discussion :

[FunkyTech]

Bonjour à tous

Je viens solliciter votre aide en ces jours heureux (enfin pour moi :p). Je voudrais savoir lequel de ces traitement est le plus rapide ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
mSaveAllocations.push_back(newMemoryBlock);

ou

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
mFile << "++ Allocation    | 0x" << Ptr
           << " | " << std::setw(7) << std::setfill(' ') << static_cast<int>(newMemoryBlock.Size) << " octets"
           << " | " << newMemoryBlock.File<< " (" << newMemoryBlock.Line << ")" << std::endl;

sachant qu'une structure ST_Block se compose ainsi :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
struct ST_Block
{
	void*	       address;
        std::size_t   size;
        File		 file;
        unsigned int line;	
        bool		anArray;
};

Merci d'avance

[befalimpertinent]

En faisant chauffer la boule de cristal je peux te dire ...qu'il doit manquer un morceaux à ton post parceque:

Je voudrais savoir lequel de ces traitement est le plus rapide ?

Encore faudrait-il que les deux traitements est le même but.

Dans 1 cas tu inseres dans un std::vector (et encore comme on a pas la déclaration c'est une supposition) un MemoryBlock et dans le 2eme cas tu affiches l'adresse et des infos d'un certain Ptr et d'un certain newMemoryBlock dont on ne sait absolument rien.

Bref on peut pas en dire beaucoup plus.

[FunkyTech]

Je sais qu'ils n'ont pas le même but, mais c'est par la suite que j'utilise le vecteur.
Ensuite est bien mon fameux "ptr" n'est qu'un pointeur vers n'importe quel type de variable (entier...)
Je voudrais juste savoir laquelle de ces 2 opérations et la plus rapide sachant que l'une d'entre elle sera très souvent utilisée (c'est pour un memory manager)

Donc en fait voici le principe : vaut t'il mieux stocker à chaque "new" dans un vecteur ou au contraire directement afficher à chaque "new".

Merci

[Emmanuel Deloget]

Je sais qu'ils n'ont pas le même but, mais c'est par la suite que j'utilise le vecteur.
Ensuite est bien mon fameux "ptr" n'est qu'un pointeur vers n'importe quel type de variable (entier...)
Je voudrais juste savoir laquelle de ces 2 opérations et la plus rapide sachant que l'une d'entre elle sera très souvent utilisée (c'est pour un memory manager)

Donc en fait voici le principe : vaut t'il mieux stocker à chaque "new" dans un vecteur ou au contraire directement afficher à chaque "new".

Merci

euh...

Mieux vaut faire ce que tu as besoin de faire ?

Je suis comme befalimpertinent - un peu perplexe. Quel est le but de mSaveAllocations ? Sert-il uniquement pour un affichage ultérieur (auquel cas la réponse est triviale). Si il sert à autre chose, alors la question n'a pas vraiment de sens.

En bref : est-ce que tu peux élaborer stp ? merci

[babar63]

Cette partie est présente dans le tutoriel de laurent gomila sur la conception du moteur3D c'est bien de ca qu'il s'agit?
Le code que tu as présenté :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
mFile << "++ Allocation    | 0x" << Ptr
           << " | " << std::setw(7) << std::setfill(' ') << static_cast<int>(newMemoryBlock.Size) << " octets"
           << " | " << newMemoryBlock.File<< " (" << newMemoryBlock.Line << ")" << std::endl;

Sert uniquement à tracer les événements du memory manager. Les blocs de mémoire sont quand à eux inséré dans une map, contenant l'adresse du pointeur(la clé) et le block(file,line,size...)permettant d'ajouter des informations sur le pointeur.

Donc attention de ne pas confondre il te faut les deux codes présenté (du moins si tu veux écrire dans un fichier ce qui se passe) en remplaçant

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

mSaveAllocations.push_back(newMemoryBlock);

par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

MyMap.insert(...);

[FunkyTech]

Voici un peu de code qui j'espère va vous éclairez :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
void* MemoryManager::allocate(size_t size, const char* file, unsigned int line, bool anArray)
{
	mNumNewCalls++;
 
	// Allocation of the memory
    void* ptr = malloc(size);
 
    // Adding the block to the list of allocated blocks
    ST_Block newMemoryBlock;
	//newMemoryBlock.address	= &ptr;
    newMemoryBlock.size		= size;
    newMemoryBlock.file		= file;
    newMemoryBlock.line		= line;
    newMemoryBlock.anArray	= anArray;
    mBlocks[ptr]			= newMemoryBlock;
 
	mAllocationsReport.push_back(newMemoryBlock);
 
	// Keep track of number of allocated blocks and bytes.
    mNumBlocks++;
    mNumBytes += size;
 
    return ptr;
}

Et donc quand je quitte mon programme...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
void MemoryManager::generateReport()
{
	 // Total calls.
    mFile << "Total number of 'new' calls = "
        << mNumNewCalls << std::endl;
    mFile << "Total number of 'delete' calls = "
        << mNumDeleteCalls << std::endl;
 
    // Remaining counts.
    mFile << "Remaining number of blocks = "
        << mNumBlocks << std::endl;
    mFile << "Remaining number of bytes  = "
        << static_cast<unsigned int>(mNumBytes) << std::endl << std::endl;
 
	mFile << "ALLOCATION REPORT" << std::endl;
	for (AllocationsReport::iterator i = mAllocationsReport.begin(); i != mAllocationsReport.end(); ++i)
    {
		mFile << "   Allocation | 0x" << &(*i).address
			<< " | "   << std::setw(7) << std::setfill(' ') << static_cast<int>((*i).size) << " octets"
			<< " | "   << (*i).file << " (" << (*i).line << ")" << std::endl;
	}
	mAllocationsReport.clear();
 
	mFile << std::endl << "DEALLOCATION REPORT" << std::endl;
	for (DeallocationsReport::iterator i = mDeallocationsReport.begin(); i != mDeallocationsReport.end(); ++i)
    {
		mFile << "   Deallocation | 0x" << &(*i).address
			<< " | "   << std::setw(7) << std::setfill(' ') << static_cast<int>((*i).size) << " octets"
			<< " | "   << (*i).file << " (" << (*i).line << ")" << std::endl;
	}
	mDeallocationsReport.clear();
 
	if (mBlocks.empty())
    {
        mFile << std::endl;
        mFile << " ------------------------------------------------------" << std::endl;
        mFile << "                  No leak detected					" << std::endl;
        mFile << " ------------------------------------------------------" << std::endl << std::endl;
    }
    else
    {
		mFile << std::endl;
        mFile << " ------------------------------------------------------" << std::endl;
        mFile << "            WARNING -> memory leaks detected !        " << std::endl;
        mFile << " ------------------------------------------------------" << std::endl << std::endl;
		generateMemoryLeaksReport();
   	}
}

Si j'utilise ici un vector (mAllocationsReport) c'est pour éviter d'écrire dans un fichier à chaque appel à new ou delete (j'espère ainsi gagner quelques précieuses secondes), j'écris simplement tout le rapport quand je quitte l'application