Se connecter avec
S'enregistrer | Connectez-vous

manipulation de std::vector problème de mémoire

Dernière réponse : dans Programmation

Bonjour a tous!

Je suis confronte a de serieux problemes avec la manipulation des std::vector en c++ avec Visual .Net 2003. J' ai developpe un algorithme qui doit gerer des listes d objets assez complexes j utilise donc des vector pour les stocker.

Jusque la pas trop de probleme mais par la suite j ai tente d integrer mon algorithme a un autre projet que j ai adapte et les methodes communiquent par le biais de std::vector< std::vector<int> > de maniere iterative. Mais mon programme fini par s arreter pour cause de probleme de memoire de ce type:


Citation:
Microsoft C++ exception: std::bad_alloc @ 0x0012ecac.


Y a t-il un probleme connu avec le fait d envoyer d envoyer en parametres des pointeurs sur des std::vector et de retourner des objets de type std::vector par le biais de methodes d'objet ou de methode statique.

Voici un exemple de code contenue dans une methode appele de facon iterative:


Code :
std::vector<int> mvRef;
int num4x4Blocks = width/4*height/4;
blocks4x4.reserve(num4x4Blocks);
mvRef.reserve(2*num4x4Blocks);

//
//
// Insertion des valeurs dans mvRef a l'aide de differentes
// methodes
//
//


return mvRef; // Ceci cree une erreur de type memory a la 2 eme
// iteration
Notez qu'il suffit de modifier un bout de code pour que l erreur apparaissent dans une autre methode qui a le meme genre de procede



Toutes vos suggestions sont les bienvenues...

Autres pages sur : manipulation std vector probleme memoire

Lassé par la pub ? Créez un compte

Ok si tu souhaites avoir un peu plus de details et bien en voici:



std::vector<int> Multigrid::methodeMultigrid16x16(unsigned char* I_Y, unsigned char* P_Y, unsigned char* prediction,
unsigned char* predictionBlocks, unsigned char* blocksMap, int step, int width,
int height, int precision, unsigned int* complexity, unsigned char* prediction4x4)
{
int num128x128Blocks = width/128*height/128;

int numLevels = log10(double(128/(precision)))/log10(2.0)+1;

int maxNumBlocks = num128x128Blocks;

int add = num128x128Blocks;

for (int i=0; i<numLevels-1; i++)
{
add = 4*add;
maxNumBlocks = maxNumBlocks + add;
}
int count=0;

std::vector<Block*> blocks;
blocks.reserve(maxNumBlocks);

for (int i=0; i<maxNumBlocks; i++)
{
Block* block = new Block();
blocks.push_back(block);
}



Block::p rocess(I_Y, P_Y, &count, step, width, height, &numLevels, complexity, blocks);

// Block vector for mapping
std::vector<Block*> blocks4x4;

std::vector<int> mvRef;
int num4x4Blocks = width/4*height/4;
blocks4x4.reserve(num4x4Blocks);
mvRef.reserve(2*num4x4Blocks);

for (int i=0; i<num4x4Blocks; i++)
{
Block* block = new Block();
blocks4x4.push_back(block);
}

//Mapping multigrid Blocks to 4x4 blocks
Block::mappingBlocks4x4(&count,blocks4x4, blocks);
Multigrid::constructMultigridPrediction(I_Y, prediction,count, predictionBlocks, blocksMap,blocks);
Multigrid::constructPrediction4x4(I_Y, prediction4x4, num4x4Blocks, blocks4x4);

blocks.clear();

//Inserting motion vectors in the motion Vector list

for (int i=0; i<num4x4Blocks; i++)
{
int v0 = blocks4x4->motionVector[0];
int v1 = blocks4x4->motionVector[1];
mvRef.push_back(v0);
mvRef.push_back(v1);
}



blocks4x4.clear();




return mvRef;


}

En general les valeurs de width et de height sont respectivement 512 et 384, mais le but final serait d utiliser des valeurs 1024 et 768

Et je pense certainement qu'une premiere chose a faire serait d'envoyer des pointeurs sur les objets de types vecteurs a la methode Block::p rocess plutot que les objets eux memes afin de ne pas surcharger le programme du point de vue allocation memoire de plus que cette methode ne fait que de modifier les differents attribus des objets de type Block contenus dans les vecteurs

desole

[code]

std::vector<int> Multigrid::methodeMultigrid16x16(unsigned char* I_Y, unsigned char* P_Y, unsigned char* prediction,
unsigned char* predictionBlocks, unsigned char* blocksMap, int step, int width,
int height, int precision, unsigned int* complexity, unsigned char* prediction4x4)
{
int num128x128Blocks = width/128*height/128;

int numLevels = log10(double(128/(precision)))/log10(2.0)+1;

int maxNumBlocks = num128x128Blocks;

int add = num128x128Blocks;

for (int i=0; i<numLevels-1; i++)
{
add = 4*add;
maxNumBlocks = maxNumBlocks + add;
}
int count=0;

std::vector<Block*> blocks;
blocks.reserve(maxNumBlocks);

for (int i=0; i<maxNumBlocks; i++)
{
Block* block = new Block();
blocks.push_back(block);
}



Block::p rocess(I_Y, P_Y, &count, step, width, height, &numLevels, complexity, blocks);

// Block vector for mapping
std::vector<Block*> blocks4x4;

std::vector<int> mvRef;
int num4x4Blocks = width/4*height/4;
blocks4x4.reserve(num4x4Blocks);
mvRef.reserve(2*num4x4Blocks);

for (int i=0; i<num4x4Blocks; i++)
{
Block* block = new Block();
blocks4x4.push_back(block);
}

//Mapping multigrid Blocks to 4x4 blocks
Block::mappingBlocks4x4(&count,blocks4x4, blocks);
Multigrid::constructMultigridPrediction(I_Y, prediction,count, predictionBlocks, blocksMap,blocks);
Multigrid::constructPrediction4x4(I_Y, prediction4x4, num4x4Blocks, blocks4x4);

blocks.clear();

//Inserting motion vectors in the motion Vector list

for (int i=0; i<num4x4Blocks; i++)
{
int v0 = blocks4x4->motionVector[0];
int v1 = blocks4x4->motionVector[1];
mvRef.push_back(v0);
mvRef.push_back(v1);
}





blocks4x4.clear();



return mvRef;


}

non pardon:

  1. std::vector<int> Multigrid::methodeMultigrid16x16(unsigned char* I_Y, unsigned char* P_Y, unsigned char* prediction, 
  2. 					unsigned char* predictionBlocks, unsigned char* blocksMap, int step, int width,
  3. 					int height, int precision, unsigned int* complexity, unsigned char* prediction4x4)
  4. {
  5. 	int num128x128Blocks = width/128*height/128;
  6.  
  7. 	int numLevels = log10(double(128/(precision)))/log10(2.0)+1;
  8.  
  9. 	int maxNumBlocks = num128x128Blocks;
  10.  
  11. 	int add = num128x128Blocks;
  12.  
  13. 	for (int i=0; i<numLevels-1; i++)
  14. 	{
  15. 		add = 4*add;
  16. 		maxNumBlocks = maxNumBlocks + add;
  17. 	}
  18. 	int count=0;
  19.  
  20. 	std::vector<Block*> blocks;
  21. 	blocks.reserve(maxNumBlocks);
  22.  
  23. 	for (int i=0; i<maxNumBlocks; i++)
  24. 	{
  25. 		Block* block = new Block();
  26. 		blocks.push_back(block);
  27. 	}
  28.  
  29.  
  30.  
  31. 	Block::process(I_Y, P_Y, &count, step, width, height, &numLevels, complexity, blocks);
  32.  
  33. 	// Block vector for mapping
  34. 	std::vector<Block*> blocks4x4;
  35. 	std::vector<int> mvRef;
  36. 	int num4x4Blocks = width/4*height/4;
  37. 	blocks4x4.reserve(num4x4Blocks);
  38. 	mvRef.reserve(2*num4x4Blocks);
  39.  
  40. 	for (int i=0; i<num4x4Blocks; i++)
  41. 	{
  42. 		Block* block = new Block();
  43. 		blocks4x4.push_back(block);
  44. 	}
  45.  
  46. 	//Mapping multigrid Blocks to 4x4 blocks
  47. 	Block::mappingBlocks4x4(&count,blocks4x4, blocks);
  48. 	Multigrid::constructMultigridPrediction(I_Y, prediction,count, predictionBlocks, blocksMap,blocks);
  49. 	Multigrid::constructPrediction4x4(I_Y, prediction4x4, num4x4Blocks, blocks4x4);
  50.  
  51. 	blocks.clear();
  52.  
  53. 	//Inserting motion vectors in the motion Vector list
  54.  
  55. 	for (int i=0; i<num4x4Blocks; i++)
  56. 	{
  57. 		int v0 = blocks4x4[i]->motionVector[0];
  58. 		int v1 = blocks4x4[i]->motionVector[1];
  59. 		mvRef.push_back(v0);
  60. 		mvRef.push_back(v1);
  61. 	}
  62.  
  63.  
  64.  
  65.  
  66. 	blocks4x4.clear();
  67.  
  68.  
  69. 	return mvRef;
  70.  
  71.  
  72. }

au fait, la méthode clear sur un vecteur ne détruit pas les objet pointé (puisque le vecteur ne sait pas que c'est un pointeur)

faut donc que tu supprimes les Block que tu crées avant de sortir de ta fonction (a condition que tu ne refile pas l'appartenance a quelqu'un d'autre)

Voici les instances de Block:

  1. int position[2];
  2. 	int width;
  3. 	int height;
  4. 	int level;
  5. 	bool isSplitted;
  6. 	bool isCreated;
  7. 	bool mustSplit;
  8. 	int motionVector[2];
  9. 	int parentNeighbour1Vector[2];
  10. 	int parentNeighbour2Vector[2];
  11. 	int parentNeighbour3Vector[2];


Ok donc lorsque les vecteus contiennent des valeurs pointees et qu on fait un appel a clear(), ces derniers ne sont pas supprimes?

Donc je dois effectue une boucle du genre:

  1. for (int i=0; i<num4x4Blocks; i++)
  2. 	{
  3. 		delete blocks4x4[i];
  4. 	}


?

Citation :
Voici les instances de Block:

  1. int position[2];
  2. 	int width;
  3. 	int height;
  4. 	int level;
  5. 	bool isSplitted;
  6. 	bool isCreated;
  7. 	bool mustSplit;
  8. 	int motionVector[2];
  9. 	int parentNeighbour1Vector[2];
  10. 	int parentNeighbour2Vector[2];
  11. 	int parentNeighbour3Vector[2];
merci
Citation :


Ok donc lorsque les vecteus contiennent des valeurs pointees et qu on fait un appel a clear(), ces derniers ne sont pas supprimes?
oui
Citation :

Donc je dois effectue une boucle du genre:

  1. for (int i=0; i<num4x4Blocks; i++)
  2. 	{
  3. 		delete blocks4x4[i];
  4. 	}


?

non, autant etre propre et utiliser les itérateurs qui sont la pour ca
  1. for ( std::vector<Block*>::iterator it = blocks.begin() ; it != blocks.end(); ++it) {
  2.   delete *it;
  3. } 
  4. bocks.clear();

et tu fais pareil pour blocks4x4

je te conseil aussi de faire des typedef pour tes vecteurs que tu utilises souvent, cela rendra ton code beaucoup plus lisible

J'ai modifier le code comme tu me l'as conseille mais maintenant le probleme apparait a un endroit plus avance de la meme iteration:

  1. std::vector<int> Multigrid::methodeMultigrid16x16(unsigned char* I_Y, unsigned char* P_Y, unsigned char* prediction, 
  2. 										unsigned char* predictionBlocks, unsigned char* blocksMap, int step, int width,
  3. 										int height, int precision, unsigned int* complexity, unsigned char* prediction4x4)
  4. {
  5. 	int num128x128Blocks = width/128*height/128;
  6.  
  7. 	int numLevels = log10(double(128/(precision)))/log10(2.0)+1;
  8.  
  9. 	int maxNumBlocks = num128x128Blocks;
  10.  
  11. 	int add = num128x128Blocks;
  12.  
  13. 	for (int i=0; i<numLevels-1; i++)
  14. 	{
  15. 		add = 4*add;
  16. 		maxNumBlocks = maxNumBlocks + add;
  17. 	}
  18. 	int count=0;
  19.  
  20. 	std::vector<Block*> blocks;
  21. 	blocks.reserve(maxNumBlocks);
  22.  
  23. 	for (int i=0; i<maxNumBlocks; i++)
  24. 	{
  25. 		Block* block = new Block();   //--------> APPARITION DU MEME PROBLEME DE MEMOIRE!!!!!!!!
  26. 		blocks.push_back(block);
  27. 	}
  28.  
  29.  
  30.  
  31. 	Block::process(I_Y, P_Y, &count, step, width, height, &numLevels, complexity, blocks);
  32.  
  33. 	// Block vector for mapping
  34. 	std::vector<Block*> blocks4x4;
  35.  
  36. 	std::vector<int> mvRef;
  37. 	int num4x4Blocks = width/4*height/4;
  38. 	blocks4x4.reserve(num4x4Blocks);
  39. 	mvRef.reserve(2*num4x4Blocks);
  40.  
  41. 	for (int i=0; i<num4x4Blocks; i++)
  42. 	{
  43. 		Block* block = new Block();
  44. 		blocks4x4.push_back(block);
  45. 	}
  46.  
  47. 	//Mapping multigrid Blocks to 4x4 blocks
  48. 	Block::mappingBlocks4x4(&count,blocks4x4, blocks);
  49. 	Multigrid::constructMultigridPrediction(I_Y, prediction,count, predictionBlocks, blocksMap,blocks);
  50. 	Multigrid::constructPrediction4x4(I_Y, prediction4x4, num4x4Blocks, blocks4x4);
  51.  
  52. 	for ( std::vector<Block*>::iterator it = blocks.begin() ; it != blocks.end(); ++it) 
  53. 	{
  54. 			delete *it;
  55. 	}
  56.  
  57. 	blocks.clear();
  58.  
  59.  
  60. 	//Inserting motion vectors in the motion Vector list
  61.  
  62. 	for (int i=0; i<num4x4Blocks; i++)
  63. 	{
  64. 		int v0 = blocks4x4[i]->motionVector[0];
  65. 		int v1 = blocks4x4[i]->motionVector[1];
  66. 		mvRef.push_back(v0);
  67. 		mvRef.push_back(v1);
  68. 	}
  69.  
  70.  
  71.  
  72. 	for ( std::vector<Block*>::iterator it = blocks4x4.begin() ; it != blocks4x4.end(); ++it) 
  73. 	{
  74. 			delete *it;
  75. 	}
  76.  
  77.  
  78.  
  79. 	blocks4x4.clear();
  80.  
  81.  
  82.  
  83. 	return mvRef;
  84.  
  85.  
  86. }



Voici les messages du debug:

  1. kernel32.dll!7c81eb33() 	
  2.  	kernel32.dll!7c81eb33() 	
  3.  	msvcr71d.dll!_nh_malloc_dbg(unsigned int nSize=1, int nhFlag=3, int nBlockUse=1240264, const char * szFileName=0x0012ee50, int nLine=1240724)  Line 267 + 0x7	C
  4.  	msvcr71d.dll!_CxxThrowException(void * pExceptionObject=0x0012ece4, const _s__ThrowInfo * pThrowInfo=0x104f6150)  + 0x39	C++
  5.  	msvcp71d.dll!std::_Nomemory()  Line 10	C++
  6. >	H264AVCEncoderLibTestStaticd.exe!operator new(unsigned int size=60)  Line 15	C++
  7.  	H264AVCEncoderLibTestStaticd.exe!Multigrid::methodeMultigrid16x16(unsigned char * I_Y=0x06e89ff8, unsigned char * P_Y=0x04d7e028, unsigned char * prediction=0x06eba038, unsigned char * predictionBlocks=0x06eea078, unsigned char * blocksMap=0x06f1a0b8, int step=16, int width=512, int height=384, int precision=4, unsigned int * complexity=0x0012eee4, unsigned char * prediction4x4=0x06f4a0f8)  Line 84 + 0x7	C++


Et l endroit precis du crash:

  1. void *__cdecl operator new(size_t size) _THROW1(_STD bad_alloc)
  2. 	{	// try to allocate size bytes
  3. 	void *p;
  4. 	while ((p = malloc(size)) == 0)
  5. 		if (_callnewh(size) == 0)
  6. 			_STD _Nomemory();
  7. 	return (p); //------------>ENDROIT DU CRASH!!!!!!!!!!!!!!!!!!
  8. 	}

maxNumBlocks est d un ordre de grandeur allant de 17'000 environ. En ce qui concerne add je l utilise simplement de blocks (= de carres, si tu veux) maximum que j obtient lorsque je cadrille un carre d une taille width*height en commencant par des blocks 128*128 ensuite 64*64 et ainsi de suite et ce jusqu'a precision*precision. Dans le cas precis precision vaut 4

Effectivement je n utilise pas tout mais ce nombre correspond a la borne maximale. Effectivement peut etre que je devrais tenter de reduire ce nombre a une valeur plus plausible mais quoiqu il en soit je dois absolument utiliser les 12'288 objets de blocks4x4, pas de reduction possible a ce niveau la. D autant plus que l ideal serait que j en utilise 4x plus a la longue mais bon....c est encore une autre histoire

Ce qui est bizarre c est que la 1er iteration se passe sans encombre et que normalement tous la memoire devrait etre liberee des la sortie de la methode n'est-ce pas? donc je comprends pas que la 2eme iteration pose probleme d autant plus que le probleme ne s etait pas tjrs poser

si tu sais pas ce que sont les références ... [:pingouino]

void fct (T a) -> passage par valeur
void fct (T * a) -> passage par pointeur
void fct (T & a) -> passage par référence, s'utilise comme par valeur mais a le meme effet que comme pointeur

Finalement je me suis resigne a utilier un tableau de pointeurs a la place des vecteurs car meme n utilisant que du referencement ( c est a dire en ne transmettant jamais une copie d un objet envoye en parametre a une methode mais plutot la reference de ce dernier) et ca plante moins facilement. Mais comme mon programme est engage dans un boucle qui devrais selon les cas atteindre jusqu a un maximum de 1000 iterations environ, Je fini tout de meme par avoir un runtime error et mon programme se voit forcer d etre interrompu par le system. Pourtant ma contribution n est qu un plug in a un soft qui tourne deja sans aucun probleme meme avec plus de 1000 iteration. Je sais que la coquille vient de mon bout de code mais ou exactement? aucune idee. Je crois avoir tout essaye. Cependant j ai remarque un phenomene bizarre: lorsque la reference a **blocks est envoye en paremetre (&blocks) a une methode qui ne fait que de lire les valeurs pointee sans en modifier aucune elles sont alteree des la fin de l execution de la methode. D ou peut venir ce genre de phenomenes en general?
Lassé par la pub ? Créez un compte

Répondre Créer un nouveau sujet