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. The program 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 again. 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. The code below lacks some error
checking to keep it short, 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
 [EMAIL PROTECTED]
_________________________________________________________
  



_______________________________________________
Linuxppc-dev mailing list
Linuxppc-dev@ozlabs.org
https://ozlabs.org/mailman/listinfo/linuxppc-dev