[ELDK] pthread / TQM5200 problem

[Sebastian Theiss]

Hi all.

I've been having some headache using the pthread library with a TB5200 box
(based on a TQM5200 board with a Freescale MPC5200 PowerPC-CPU). I created a
small program to pin down the problem and it runs fine on all my Unix- and
Linux-machines but fails on the embedded box. The program contains a class
CSignal that provides thread-synchronisation based on the
pthread_cond_signal and pthread_cond_wait calls and takes care of the
"spurious wakeup" and "lost signal" problems. It runs 159 additional threads
(that seems to be some internal limit), each of them continuously increments
a field variable and afterwards sleeps until the main thread wakes it up.
The main thread monitors the whole field of variables that are incremented
by the 159 other threads and continuously wakes them up. When running in the
desired way, the program should show a table with 160 entries and each entry
(except for the last) should continuously increase. However, on the box the
threads 31 to 64 never wake up, once they call pthread_cond_wait. My code
lacks some error checking but besides that I don't see what's going wrong.
And, the code runs fine on my "real" Linux machines.

Any ideas of what the problem might be and how to fix it? Your I help would
be greatly appreciated as I'm rather despaired right now.

Regards,
Sebastian


#include <stdio.h>
#include <pthread.h>

class CSignal
{
public:
	CSignal()
	{
		m_bFlag = false;
		pthread_mutex_init(&m_Mutex, NULL);
		pthread_cond_init(&m_Condition, NULL);
	}

	~CSignal()
	{
		pthread_mutex_destroy(&m_Mutex);
		pthread_cond_destroy(&m_Condition);
	}

public:
	void Set(bool bValue = true)
	{
		pthread_mutex_lock(&m_Mutex);
		if( m_bFlag = bValue ) pthread_cond_broadcast(&m_Condition);
		pthread_mutex_unlock(&m_Mutex);
	}

	void Wait()
	{
		pthread_mutex_lock(&m_Mutex);
		while( !m_bFlag ) pthread_cond_wait(&m_Condition,&m_Mutex);
		pthread_mutex_unlock(&m_Mutex);
	}

protected:
	volatile bool m_bFlag;
	pthread_mutex_t m_Mutex;
	pthread_cond_t m_Condition;
};

#define THREAD_COUNT 160
unsigned char state[THREAD_COUNT];
CSignal signal[THREAD_COUNT];

void* threadproc(void* pParam)
{
	int index = (int)pParam;

	while( true )
	{
		state[index]++;
		// wait for the signal beeing set
		signal[index].Wait();
		// reset signal, so that next Wait() will actually case the
thread to sleep again
		signal[index].Set(false);
	}
}

int main()
{
	// clear state field
	for( int i = 0; i < THREAD_COUNT; i++ )
	{
		state[i] = 0;
	}

	// run 160 threads (creation of the last thread throws EAGAIN, so
159 (+ the main thread) 
	// seems to be some kind of limit, but that's not the point here)
	for( int i = 0; i < THREAD_COUNT; i++ )
	{
		pthread_t id;
		printf("create thread %i: %i\n", i, pthread_create(&id,
NULL, threadproc, (void*)i));
	}

	for(;;)
	{
		// wake all threads
		for( int i = 0; i < THREAD_COUNT; i++ )
		{
			signal[i].Set();
		}

		// print state of each thread
		printf("\033[H");
		int thread = 0;
		for( int i = 0; i < 16; i++ )
		{
			for( int j = 0; j < 10; j++, thread++ )
			{
				printf("%03i/%03i ", thread, state[thread]);
			}
			printf("\n");
		}
	}

	return 0;
}  

 
_________________________________________________________

 Technische Universität Dresden
 Fakultät Informatik
 Institut für Angewandte Informatik
 Lehrstuhl für Technische Informationssysteme
 D-01062 Dresden

 Besucheradresse: Nöthnitzer Str. 46, Zi. 1079

 Telefon +49 351 463-38399
 Telefax +49 351 463-38460
 st12 at inf.tu-dresden.de
_________________________________________________________