Discussion :

[FunkyTech]

Bonjour à tous

Je développe actuellement un memory manager en C++. J'utilise pour stocker mes allocations une double liste chainée.
Tous marche niquel sauf lorsque j'arrive à la désallocation, l'application plante sur le free de la méthode deallocate.
Voici un bout de code pour vous éclairer :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
struct STBlock
        {
			void*		address;
            size_t		size;  ///< Taille allouée
            char*		file;  ///< Fichier contenant l'allocation
            int			line;  ///< Ligne de l'allocation
            bool		anArray; ///< Est-ce un objet ou un tableau ?
			STBlock*	previousBlock;
			STBlock*	nextBlock;
        };

mFirst corresponde au premier élément de ma liste chainée et mLast au dernier.

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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
 
MemoryManager::STBlock* MemoryManager::mFirst = NULL;
MemoryManager::STBlock* MemoryManager::mLast = NULL;
 
//-----------------------------------------------------
// Allocate memory space for object(s).
//-----------------------------------------------------
void* MemoryManager::allocate(std::size_t size, char* file, int line, bool anArray)
{
	mNumNewCalls++;
 
	assert(size > 0);
 
    // Allocation de la mémoire
    void* ptr = malloc(size);
 
	// Save the allocation information.
    STBlock* newBlock	= (STBlock*)ptr;
	newBlock->address	= &ptr;
    newBlock->size		= size;
    newBlock->file		= file;
    newBlock->line		= line;
    newBlock->anArray	= anArray;
	pushBackElement(newBlock);
 
	// Keep track of number of allocated blocks and bytes.
    mNumBlocks++;
    mNumBytes += size;
 
    return ptr;
}
 
//-----------------------------------------------------
// Free memory space for object(s).
//-----------------------------------------------------
void MemoryManager::deallocate(void* ptr, bool anArray)
{
	mNumDeleteCalls++;
 
    if(!ptr)
		return;
 
	STBlock* deleteBlock = (STBlock*)ptr;
 
	if(deleteBlock->anArray == anArray)
	{
 
	popElement(deleteBlock);
 
    // Libération de la mémoire
    free(ptr);
	}
}
 
//-----------------------------------------------------
// Insert a block in the doubly linked list.
//-----------------------------------------------------
void MemoryManager::pushBackElement(STBlock* block)
{
	assert(block);
	block->previousBlock = mLast;
	block->nextBlock = NULL;
 
	if(mLast)
	{
		mLast->nextBlock = block;
	}
	else
	{
		mFirst = block;
	}
	mLast = block;
}
 
//-----------------------------------------------------
// Remove a block in the doubly linked list.
//-----------------------------------------------------
void MemoryManager::popElement(STBlock* block)
{
	STBlock* myBlock = mFirst;
	while(myBlock != block)
		myBlock = myBlock->nextBlock;
 
	if(myBlock == block)
	{
		if((myBlock == mLast) && (mLast == mFirst))
		{
			return;
		}
		else if ((myBlock == mLast) && (mLast != mFirst))
		{
			myBlock->previousBlock->nextBlock = NULL; 
			mLast = myBlock->previousBlock;
			mLast->previousBlock->nextBlock = mLast;
		}
		else if((myBlock == mFirst) && (mFirst != mLast))
		{
			mFirst = myBlock->nextBlock;
			mFirst->nextBlock->previousBlock = mFirst;
		}
		else
		{
			myBlock->previousBlock->nextBlock = myBlock->nextBlock;
			myBlock->nextBlock->previousBlock = myBlock->previousBlock;
		}
	}
}

Pour vous aidez, lors de l'appel au delete voici ce qu'il me dit dans la fenêtre de déboggage : previousBlock et nextBlock : impossible d'évaluer les expressions de la structure STBlock.

Si quelqu'un à une petite idée

Merci d'avance à plus

[screetch]

tu alloues de la memoire, y stocke des informations et envoie ca a ton programme. a moins que ton programme n'y touche pas, il va reecrire dessus et changer tes pointeurs...

[Médinoc]

Si tu veux mettre ton STBlock dans la même zone que celle que tu alloues pour le programme, tu dois allouer sizeof STBlock + size, et retourner un pointeur sur la zone disponible pour l'utilisateur...

[FunkyTech]

Merci Médinoc cela à résolu mon problème, mais j'ai maintenant un second problème, quand je quitte mon application, il m'indique le nombre d'appel à new et à delete, j'en déduis s'il y'a une fuite de mémoire.

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
 
if(mNumNewCalls - mNumDeleteCalls == 0)
{
     mFile << "No memory leaks detected" << std::endl;
}
else
{
     mFile << "WARNING -> memory leaks detected ! " << std::endl << std::endl;
     while(block)
     {
          totalSize += block->size;
 
          mFile << "-> 0x" << &block->address
          << " | "   << std::setw(7) << std::setfill(' ') << static_cast<int>(block->size) << " octets"
          << " | "   << block->file << " (" << block->line << ")" << std::endl;
 
          // Free memory.
          free((void*)block);
 
          block = block->nextBlock;
    }
}

Je simule une et une seule fuite mémoire pour tester le log de celle-ci.

Lors du premier passage tout ce passe bien et il me logge la fuite, cependant il fait un second passage alors que block->nextBlock vaut NULL et donc la il plante en arrivant sur la ligne totalSize += block->size; (size : impossible d'évaluer l'expression)

Je ne comprend pas pourquoi il passe une seconde fois dans la boucle

[nicroman]

Je trouve le code du pop un peu compliqué... j'ai pas vraiment regardé en détail, mais en général on a un truc genre:

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
 
struct STBlock {
    STBlock*   next;
    STBlock*   prev;
    bool          inlist;
    ...
 
 
    static STBlock* first;
    static STBlock* last;
    static Mutex mutex;
};
 
STBlock* STBlock::first = 0;
STBlock* STBlock::last= 0;
 
void pushBlock(STBlock* block)
{
     assert(!block->inlist);
     STBlock::mutex.acquire();
     block->inlist = true;
     block->next = 0;
     if (block->prev = STBlock::last)
         block->prev->next = block;
     else
         STBlock::first = block;
     STBlock::last = block;
     STBlock::mutex.release();
}
 
void popBlock(STBlock* block)
{
     assert(block->inlist);
     STBlock::mutex.acquire();
     if (block->next)
         block->next->prev = block->prev;
     else
         STBlock::last = block->prev;
     if (block->prev)
         block->prev->next = block->next;
     else
         STBlock::first = block->next;
     block->inlist = false;
     STBlock::mutex.release();
}

[FunkyTech]

Voici le code final, avec simplement le bog cité précedemment dans la fonctiion generateMemoryReport

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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
 
#include "MemoryManager.h"
#include "Logger.h"
 
using namespace Tech;
 
unsigned int MemoryManager::mNumBlocks = 0;
size_t MemoryManager::mNumBytes = 0;
unsigned int MemoryManager::mNumNewCalls = 0;
unsigned int MemoryManager::mNumDeleteCalls = 0;
MemoryManager::TBlock* MemoryManager::mFirst = NULL;
MemoryManager::TBlock* MemoryManager::mLast = NULL;
std::ofstream MemoryManager::mFile("Memory Report.log");
 
//-----------------------------------------------------
// Allocate memory space for object(s).
//-----------------------------------------------------
void* MemoryManager::allocate(std::size_t size, char* file, int line, bool anArray)
{
	assert(size > 0);
 
	// Allocate additional storage for the block header information.
    size_t extendedSize = sizeof(TBlock) + size;
    char* ptr = (char*)malloc(extendedSize);
 
	// Save the allocation information in the TBlock structure.
    TBlock* newBlock	= (TBlock*)ptr;
	newBlock->address	= &ptr;
    newBlock->size		= size;
    newBlock->file		= file;
    newBlock->line		= line;
    newBlock->anArray	= anArray;
	insertBlock(newBlock);
 
	// Move the pointer to the start of what the user expects from 'new'.
    ptr += sizeof(TBlock);
 
	// Keep track of number of allocated blocks and bytes.
    mNumBlocks++;
    mNumBytes += size;
 
	mFile << "++ Allocation | 0x" << &newBlock->address
    << " | " << std::setw(7) << std::setfill(' ') << static_cast<int>(newBlock->size) << " octets"
    << " | " << newBlock->file << " (" << newBlock->line << ")" << std::endl;
 
	Logger::log() << "test";
    return static_cast<void*>(ptr);
}
 
//-----------------------------------------------------
// Free memory space for object(s).
//-----------------------------------------------------
void MemoryManager::deallocate(char* reportAddress, bool anArray)
{
    if(!reportAddress)
		return;
 
	// Move the pointer to the start of the actual allocated block.
    reportAddress -= sizeof(TBlock);
 
	TBlock* deleteBlock = (TBlock*)reportAddress;
 
	if(deleteBlock->anArray == anArray)
	{
		removeBlock(deleteBlock);
 
		mFile	<< "-- Deallocation| 0x" << &deleteBlock->address
				<< " | " << std::setw(7) << std::setfill(' ') << static_cast<int>(deleteBlock->size) << " octets"
				<< " | " << deleteBlock->file << " (" << deleteBlock->line << ")" << std::endl;
 
		// Deallocate the memory block.
		free(reportAddress);
	}
}
 
//-----------------------------------------------------
// Insert a block in the doubly linked list.
//-----------------------------------------------------
void MemoryManager::insertBlock(TBlock* block)
{
	mNumNewCalls++;
 
	 // New blocks are inserted at the head of the doubly linked list.
    if (mLast)
    {
        block->previousBlock = mLast;
        block->nextBlock = NULL;
        mLast->nextBlock = block;
        mLast = block;
    }
    else
    {
        block->previousBlock = NULL;
        block->nextBlock = NULL;
        mFirst = block;
        mLast = block;
    }
}
 
//-----------------------------------------------------
// Remove a block in the doubly linked list.
//-----------------------------------------------------
void MemoryManager::removeBlock(TBlock* block)
{
	mNumDeleteCalls++;
	if(block->previousBlock)
    {
        block->previousBlock->nextBlock = block->nextBlock;
    }
    else
    {
        mFirst = block->nextBlock;
    }
 
    if(block->nextBlock)
    {
        block->nextBlock->previousBlock = block->previousBlock;
    }
    else
    {
        mLast = block->previousBlock;
    }
}
 
//-----------------------------------------------------
// Generate a report about the current list memory blocks.
//-----------------------------------------------------
void MemoryManager::generateMemoryReport()
{
	// Total calls.
	mFile << std::endl << "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;
 
	TBlock* block = mFirst;
	int size = 0;
	std::size_t totalSize = 0;	
 
	if(mNumNewCalls - mNumDeleteCalls == 0)
	{
		mFile << "No memory leaks detected" << std::endl;
	}
	else
	{
		mFile << "WARNING -> memory leaks detected ! " << std::endl << std::endl;
	}
	/*	while(block)
		{
			totalSize += block->size;
 
			mFile	<< "-> 0x" << &block->address
					<< " | "   << std::setw(7) << std::setfill(' ') << static_cast<int>(block->size) << " octets"
					<< " | "   << block->file << " (" << block->line << ")" << std::endl;
 
			// Free memory.
			free((void*)block);
 
			block = block->nextBlock;
		}
 
		mFile	<< size << " blocs non-libérés(s), "
				<< static_cast<int>(totalSize) << " octets --"
				<< std::endl;
	}*/
}

[Médinoc]

Code C :

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

1
2
3
4
			// Free memory.
			free((void*)block);
 
			block = block->nextBlock;

Y'a rien qui te choque ici?

[FunkyTech]

:p l'idiot, mille excuse seigneur Médinoc^^, à trop être dans son code on ne voit plus ses erreurs

[FunkyTech]

Je tiens à remercier tous les membres de développez.com qui m'ont permis de réussir ce memory manager , je met donc à votre disposition le code final. Je remercie aussi Loulou, car sans certaines parti du code je n'aurai pas pu le faire (merci au tutoriel sur les outils^^)

Je rappel juste que ce memory manager fonctionne grâce à une liste doublement chainée, qu'il vous fait un joli rapport sur les allocation, désallocations et fuites mémoires (mais il est mignon parce qu'il vous les indiques mais les supprimes quand même^^).
Petit détails : il n'indique ni le fichier ni la ligne du delete (seulement pour le new). Je le corrigerais si j'ai le temps et je reposterai le résultat.

Bonne journée à tous
@+