Qt App Killed After 45 mins

I have written an app that runs on mini2440. I've compiled qt-everywhere-opensource-src-4.6.2 for arm and I'm using that libraries for my app. The problem is, the app runs like 40-45 minutes on arm but then I get 'Killed' message.
What can be the cause?

Quote:

---

What can be the cause?

---

'Killed' might suggest that it was killed by the system (but it doesn't have to be).
Make sure your application is not leaking, prompting the system to kill it due to it eating the systems resources.
Or, you have a segmentation fault somewhere in your code.
Or, any one of infinite other reasons - you should supply more information.

Thanks for your reply.
It is most probably about memory management issue. I call repaint function with timer(per 50 ms). I have 4 worker threads that fills 4 separate arrays and after each 50 ms I call repaint to draw the values to the screen. The gui thread works well until 45 minutes passed, then paint function is not called anymore. I'm clearing arrays in paint function so this might be the cause. The arrays causes segmentation fault some way and programs blows up. By the way, commenting out other 3 threads, with 1 working worker thread it takes about 55 minutes program to be killed.

I still have this problem. Please help me.

Quote:

---

By the way, commenting out other 3 threads, with 1 working worker thread it takes about 55 minutes program to be killed.

---

My guess is that you have a memory leak somewhere in your thread code, so having just one thread makes the memory usage grows slower (and your app can run slightly longer).

Quote:

---

I still have this problem. Please help me.

---

It's impossible without seeing the code.

I'm posting code, sorry it seems complicated. The work mechanism is like that. I create a serial and updateUIEcg thread. I'm reading from serial, and unpacking that packets. I have a counter in unpacking process and when it reaches to 40 I'm signaling updateUIEcg thread. This thread reads the points from ecg1Vector and ecg2Vector, creates lines. Also I have a timer that calls repaint every 50 ms. In my paintEvent method, I'm drawing lines and clearing line vector. I do not append points to ecg1Vector and ecg2Vector. I'm just setting beatX index to the value as you see. At some point, for example for regarding this code it takes 1 hour, line vector becomes so big and paint event starts to not being called. Until 55 or so mins passed sizes are normal. I mean they rise and down. @55 min, it suddenly grows and after 2-3 minutes program gets killed. The paintEvent method is not called anymore and it is normal that the vectors grow and causes kill. I'm wondering why my timer is not causes paintEvent call.

Code:

---

int main(int argc, char *argv[])
{
	QApplication a(argc, argv);
	MainWindow w;
	Global::w = &w;
	Global::w->showFullScreen();
	//Global::w->show();
	init();
	return a.exec();
}
 
void init()
{
	pthread_t serial;
	int thrid;
	void *t;
	thrid = pthread_create(&serial, NULL, &SerialRead, (void *) t);
	Global::stigmaECG.updateUIEcgID = pthread_create(&(Global::stigmaECG.updateUIEcgThread), NULL, &updateUIEcg, (void *) Global::stigmaECG.tEcg);
	Global::initialize();//I'm initializing integer values etc., no memory related process
}
 
void* SerialRead(void *t)
{
	//serial port
	StigmaSerialRead::fd = StigmaSerialRead::open_port();
	StigmaSerialRead::set_port(StigmaSerialRead::fd);
 
	while (1)
	{
		unsigned char* pack = stigmaSerialRead.SerialRead();
		if (pack!=NULL)
		{
			int check = StigmaSerialUtil::checksum(pack, 8);
			if (check == -2 || check == -1)
			{
				return;
			}
			unsigned char data_head = pack[1];
			unsigned char ecg1_wave_high = pack[2];
			unsigned char ecg1_wave_low = pack[3];
			unsigned char ecg2_wave_high = pack[4];
			unsigned char ecg2_wave_low = pack[5];
			unsigned char status = pack[6];
 
			if (data_head & 0x01);
			else {
				ecg1_wave_high &= 0x7F;
			}
			if (data_head & 0x02);
			else {
				ecg1_wave_low &= 0x7F;
			}
			if (data_head & 0x04);
			else {
				ecg2_wave_high &= 0x7F;
			}
			if (data_head & 0x08);
			else {
				ecg2_wave_low &= 0x7F;
			}
			if (data_head & 0x10);
			else {
				status &= 0x7F;
			}
 
			short int temp, mask;
			mask = 0xFF00;
			temp = 0;
 
			temp = ecg1_wave_high;
			temp = temp << 8;
			temp = temp & mask;
			temp += ecg1_wave_low;
 
			short int differenceGG = temp - 2048;
			pthread_mutex_lock( &(ecg_array_mutex));
			ecg1Vector[beatX] = differenceGG;
			pthread_mutex_unlock(&(ecg_array_mutex));
 
			temp = 0;
			temp = ecg2_wave_high;
			temp = temp << 8;
			temp = temp & mask;
			temp += ecg2_wave_low;
 
			pthread_mutex_lock( &(ecg_array_mutex));
			ecg2Vector[beatX] = temp - 2048;
			pthread_mutex_unlock(&(ecg_array_mutex));
 
			char mask2 = 0x01;
			temp = 0;
			temp = status & mask2;
			if (temp == 1)
			{
				printf("\007");
				fflush(stdout);
			}
			mask2 = 0x02;
			temp = 0;
			temp = status & mask2;
 
			if (temp == 1)
			{
				pacingPulse = 1;
				printf("Pacing pulse");
				fflush(stdout);
			}
 
			beatX = (++beatX) % zoommod; //2000
			ecgHandlerIndexCounter++;
			if(ecgHandlerIndexCounter == 40)
			{
				ecgHandlerIndexCounter = 0;
				pthread_mutex_lock( &(ecg_update_mutex ));
				pthread_cond_signal( &(ecg_condition_var));
				pthread_mutex_unlock( &(ecg_update_mutex ));
			}
			internalCounter++;
		}
	}
	close(StigmaSerialRead::fd);
}
 
void* updateUIEcg(void *tEcg)
{
    for(;;)
    {
		pthread_mutex_lock( &(Global::stigmaECG.ecg_update_mutex ));
		pthread_cond_wait( &(Global::stigmaECG.ecg_condition_var), &(Global::stigmaECG.ecg_update_mutex));
		Global::w->refreshEcgGraphs();
		pthread_mutex_unlock( &(Global::stigmaECG.ecg_update_mutex ));
    }
}
 
void MainWindow::refreshEcgGraphs()
{
	qreal scalex = ui->ecgChannelGraph1->calcScaleX(2000);
	qreal scaley = ui->ecgChannelGraph1->calcScaleY();
	qreal ty = ui->ecgChannelGraph1->calcTy();
    QList<QPointF> ValueList1;
    QList<QPointF> ValueList2;
 
    int ind = countEcg*40;
    for(int i=0;i<40;i++)
    {
		int sira = (ind + i)%2000;
		pthread_mutex_lock( &(Global::stigmaECG.ecg_array_mutex));
		double ecg1 = (double)(Global::stigmaECG.ecg1Vector[sira]);
		double ecg2 = (double)(Global::stigmaECG.ecg2Vector[sira]);
		pthread_mutex_unlock( &(Global::stigmaECG.ecg_array_mutex));
 
		qreal orgX = (ind+i)%2000;
		qreal xPos = orgX * scalex;
		qreal orgY1 = ecg1;
		qreal orgY2 = ecg2;
		qreal yPos1 = (orgY1 + ty) * scaley;
		qreal yPos2 = (orgY2 + ty) * scaley;
 
		QPointF *ecg1Point = new QPointF(xPos, -yPos1);
		QPointF *ecg2Point = new QPointF(xPos, -yPos2);
		ValueList1.append(*ecg1Point);
		ValueList2.append(*ecg2Point);
	}
    ui->ecgChannelGraph1->addPoint(ValueList1, QList<QList<QPointF> >(), "ECG1");
	ui->ecgChannelGraph2->addPoint(ValueList2, QList<QList<QPointF> >(), "ECG2");
 
    countEcg++;
	countEcg = countEcg%(2000/40);
}
 
int QtBasicGraph::addPoint(const QList<QPointF> pointList, QList<QList<QPointF> > gridPointList, char* type)
{
    try
    {
		Mutex.lock();
		int size = pointList.size();
		QPointF FirstPoint;
		if(lines.isEmpty())
			FirstPoint = pointList.first();
		else
			FirstPoint = lines.last().p2();
		for (int i =  1 ; i < size; i++)
		{
			QPointF pt = pointList[i];
			lines.append(QLineF(FirstPoint, pt));
			FirstPoint = pt;
		}
		gridLines.clear();
		for(int j = 0 ; j<gridPointList.size();j++)
		{
			QList<QPointF> gridLinePointPair = gridPointList.at(j);
			QPointF start = gridLinePointPair.at(0);
			QPointF end = gridLinePointPair.at(1);
			gridLines.append(QLineF(start, end));
		}
		Mutex.unlock();
    }
    catch(char * str)
    {
		qDebug()<<"error"<<str;
    }
}
 
//Repaint called every 50 ms and clearing lines, points
void QtBasicGraph::paintEvent(QPaintEvent *e)
{
    QPainter p(this);
    if (m_render_hints)
		p.setRenderHints(m_render_hints);
 
    QVarLengthArray<QLineF> temp;
    QVarLengthArray<QLineF> tempGrids;
    QVarLengthArray<QLineF> xLinelist;
    QVarLengthArray<QLineF> yLinelist;
 
    int lineIndex=0;
    Mutex.lock();
    int lineSize=lines.size();
 
    if(lineSize!=0)
    {
		temp.append(lines[0]);
    }
    for (lineIndex = 0; lineIndex < lineSize-1; lineIndex++)
    {
		if(lines[lineIndex].p1().x()<lines[lineIndex+1].p1().x())
		{
			temp.append(lines[lineIndex+1]);
		}
		else
		{
			lines.erase(lines.begin(),lines.begin()+lineIndex+1);
			if(temp[lineIndex].p2().x()<temp[lineIndex].p1().x())
			{
				temp.removeLast();
			}
			break;
		}
 
    }
    if(lineIndex==lineSize-1)
    {
		lines.erase(lines.begin(), lines.end()-1);
    }
 
    for(int i = 0; i<gridLines.size();i++)
    {
		tempGrids.append(gridLines.at(i));
    }
    Mutex.unlock();
 
    QRectF qrectf(temp[0].p1().x(), 0.0,  temp[temp.size()-1].p2().x()-temp[0].p1().x()+clearAfter, yRange());
 
    p.fillRect(qrectf, QBrush(Qt::black, Qt::SolidPattern));
 
    p.setPen(gridPen);
    p.drawLines(tempGrids.constData(), tempGrids.size());
    if(temp[0].p1().x()<20)
    {
		for (int i = 0; i < xLines.size(); ++i)
		{
			qreal lineEnd=(temp[temp.size()-1].p2().x()+clearAfter) < 20 ? temp[temp.size()-1].p2().x()+clearAfter : 20;
			xLinelist.append( QLineF(temp[0].p1().x(),-xLines[i],lineEnd,-xLines[i]));
		}
		p.drawLines(xLinelist.constData(), xLinelist.size());
    }
 
    p.setPen(lineColor);
    p.drawLines(temp.constData(), temp.size());
    temp.clear();
}

---

Code:

---

QPointF *ecg1Point = new QPointF(xPos, -yPos1);
		QPointF *ecg2Point = new QPointF(xPos, -yPos2);
		ValueList1.append(*ecg1Point);
		ValueList2.append(*ecg2Point);

---

This is a memory leak, you never delete ecg1Point and ecg2Point. No need to create them on a heap, this will be enough:

Code:

---

ValueList1.append( QPointF(xPos, -yPos1) );
ValueList2.append( QPointF(xPos, -yPos2) );

---

There may be more problems in this code, but you should do the dirty work yourself.

1 $ ./yourapp &
2 $ top
3 Stare at the %MEM column for 45mins
4 Job's a good'un

DaRab

to OP:
Your code is VERY C styled.
You are using some C++ objects, but your code is C in thought.
As such it is also very dangerous, as you work a lot with naked pointers and even more dangerous void*.
It looks that you are using vectors or lists, so at least there use the ::at() instead of operator[] as the '[]' is unsafe (the same as accessing pointer outside bounds).
It really hurts the eye to read this code, and I bet that at least some of your problems stem from how the code is written.
Pack it in classes at it should be, make it more defensive (you do not check pointer everywhere for example) and if you are using Qt, use Qt classes , such as QVecotrs, QThread ect.
This will reduce the chances for errors.
Then we can look further.
But to try and debug this even with stepping through a running debugger is madness.

Thank you high_flyer, DaRabman and stampede.

@DaRabman: I'm sorry but I couldn't understand step 4: Job's a good'un

@stampede: Thank you for your valuable advice. I will check and correct similar problems asap.

@high_flyer:
I have a very big performance issue. I've started using QT classes wherever possible but then I needed to convert them C++. I couldn't manage to access the speed which I want to. So I've slipped to C. But you are right, correctness must be thought before speed. I will change the code as you said, may the problem solved that way.

I'll inform you when it is done.

Quote:

---

Originally Posted by gokceng

@high_flyer:
I have a very big performance issue. I've started using QT classes wherever possible but then I needed to convert them C++. I couldn't manage to access the speed which I want to. So I've slipped to C. But you are right, correctness must be thought before speed. I will change the code as you said, may the problem solved that way.

---

Switching to a lower-level language will not give you much performance gain. Usually problems such as those come from the fact that the algorithm is suboptimal in its core and improving it gives a bigger boost than anything else. If your app gets killed because the system runs out of memory then probably for some time it swaps like hell which is a performance killer for the whole system. Fix the leaks and then worry about performance.