Eure Meinung zu meinem Ringpuffer

[VerbalKint]

Hallo,

ich beginne gerade an einem Programm zu schreiben, dass an einer Kamera hängt und permanent Bilder von dieser akquiriert. Diese will ich in einem Ringpuffer ablegen. Um diesen Buffer vorher zu testen, habe ich das kleine Programm weiter unten geschrieben. Meine Frage dazu wäre, ob das so effizient gelöst ist oder ob ihr vielleicht Verbesserungsvorschläge dazu habt, wie es schneller bzw. korrekt aussehen könnte? Vielen Dank!

V.K.

// Klasse, die die Bilddaten in einem Ringpuffer ablegt
class BildDaten
{
public:
	BildDaten::BildDaten(int iMax, int iX,int iY) : m_iMaxSize (iMax),m_iX (iX),m_iY(iY),m_iCnt(0)
	{
		int i,k;
		vpData = new unsigned char **[m_iMaxSize];
		for (k=0;k<m_iMaxSize;k++)
		{
			vpData[k] = new unsigned char *[m_iX];
			for (i=0;i<m_iX;i++)
				vpData[k][i] = new unsigned char [m_iY];
		}
	}
	BildDaten::~BildDaten()
	{
		int i,j;

		// Ist der Speicherplatz korrekt freigegeben?
		for (i=0;i<m_iMaxSize;i++)
		{
			for (j=0;j<m_iX;j++)
				delete[] vpData[i][j];
			delete[] vpData[i];
		}
		delete vpData;
	}

	void Add (unsigned char **pData)
	{
		int i;
		if (m_iCnt == m_iMaxSize)
			m_iCnt = 0;
		// Geht das vielleicht schneller?
		for (i=0;i<m_iX;i++)
			memcpy(vpData[m_iCnt][i],pData[i],m_iY*sizeof(pData[i]));
		m_iCnt++;
	}
	void Show ()
	{
		int i,j,k;
		for (k=0;k<m_iMaxSize;k++)
		{
			for	 (i=0;i<m_iX;i++)
			{
				for	 (j=0;j<m_iX;j++)
					std::cout << (int)vpData[k][i][j] << " ";
				std::cout << std::endl;
			}
			std::cout << std::endl;
		}
	}
private:
	int m_iCnt,m_iMaxSize,m_iX,m_iY;
	unsigned char *** vpData;
};

// Hauptfunktion
int main(int argc, char* argv[])
{
	int i,j,x,jMax,iMax,xMax;
	unsigned char **pData;

	xMax = 3;
	jMax = iMax = 3;
	BildDaten Data(xMax,iMax,jMax);

	pData = new unsigned char *[iMax];
	for (j=0;j<iMax;j++)
		pData[j] = new unsigned char [jMax];

	srand(time(0));
	for (x=0;x<4;x++)
	{
		for (i=0;i<iMax;i++)
		{
			for (j=0;j<jMax;j++)
			{
				pData[i][j] = rand()%10;
				std::cout << (int) pData[i][j] << " ";
			}
			std::cout << std::endl;
		}
		std::cout << std::endl;

		Data.Add(pData);
	}

	std::cout << std::endl;
	Data.Show();

	for (i=0;i<iMax;i++)
		delete[] pData[i];
	delete pData;
	return 0;
}

[drakon]

Wenn du wirklich wissen willst, wo der Flaschenhals ist, rate ich dir einen Profiler zu benutzen und das mal gründlich zu testen. (Pseudooptimierung bringt dir nicht viel)

AMD Codeanalyst:
http://developer.amd.com/CPU/Pages/default.aspx

Allerdings würde ich dir raten das mal mit der Standardcontainer (und Algorithmen) zu lösen.

[VerbalKint]

Hi drakon,

danke dir für Deine Antwort. Warum denkst du, dass es mit Standardcontainern besser wäre? Du meinst damit sicher die STL, oder nicht?

Was meinst du eigentlich mit dem Ausdruck Flaschenhals?

Danke dir!
V.K.

[drakon]

VerbalKint schrieb:

Hi drakon,

danke dir für Deine Antwort. Warum denkst du, dass es mit Standardcontainern besser wäre? Du meinst damit sicher die STL, oder nicht?

Was meinst du eigentlich mit dem Ausdruck Flaschenhals?

Danke dir!
V.K.

Naja. Die STL ist weitaus sicherer und unter Umständen effizienter.

Mit Flschenhals meine ich die Stelle, die wirklich am meisten Probleme macht. Also am meisten Zeit braucht bei der Verwendung.