Question de rapidité^^

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:

---

1 2	mSaveAllocations.push_back(newMemoryBlock);

---

ou

Code:

---

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:

---

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 :D

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

Citation:

---

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

---

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

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. 8O

Bref on peut pas en dire beaucoup plus.

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

Citation:

---

Envoyé par Corvus::Engine

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 ;)

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:

---

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:

---

mSaveAllocations.push_back(newMemoryBlock);

---

par

Code:

---

MyMap.insert(...);

---

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

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

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:

---

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

Je ne vois vraiment pas l'utilité d'essayer de gagner un peu de temps c'est vrai que l'écriture/lecture dans un fichier est lente mais avant tout l'utilité d'une tracker de memory leaks est d'aider le programmeur à repérer les memory leaks comme son nom l'indique!

Dans tout les cas même si on se passe de l'écriture dans le fichier l'application sera quand même ralentit par ton gestionnaire de mémoire. C'est pour ça qu'on l'utilise en mode DEBUG. Comme je l'ai dit c'est avant tout un outil nous aidant à gérer la mémoire dynamique mais il ne doit en aucun cas ralentir la version optimisé du produit final!

Ok merci à tous pour toutes vos réponses, je voulais juste d'optimiser un peu^^
@+