Search  

---

C:/temp/src/j2k/QNX4/Fred/THREADS.TXT

Go to the documentation of this file.

Hello,

    Here's the stuff.  It should be pretty self-explanatory.

    Ideally, we should have some way of encapsulating message
    sends/replies so we can send some buffers around rather than
    primitive C arrays, but right now, I'm just testing.

    This worked out of the box, BTW---no need to do anything
    bizarre (except that the C++ compiler doesn't like the bool
    type, so I had to make those ints).

    The code follows my signature.  Just 'cc thread.cc'.  It's
    lousy; I don't check all return values.  But then again,
    that's just test code, and most production code doesn't check
    all return values, either (I should know; I write production
    code during summers) :{)

    To whomever had an a.out in the c directory: I scrapped it,
    sorry. :{)  I also put the C++ code in thread.cc in the c
    subdirectory of our group directory (in other words,
    //1/home/group5/c/thread.cc)

    The technique should be applicable to other kinds of
    callbacks.  I'll work on getting support for interrupt
    handlers later this week.

    While I'm here, if you want to contact me by phone, it's
    (514) 351-2378.  I recommend you e-mail me instead unless it's
    something really, really urgent.

-- 
Benoit Goudreault-Emond -- Reply to: bge@crosswinds.net
CoFounder, KMS Group.  Student, B. CompEng, Concordia University.
A proud user of Linux---I'd rather work than nursemaid my computer.
My homepage (such as it is): http://www.crosswinds.net/~bge

/* Small thread experiment */

#include <stdio.h>
#include <stdlib.h>
#include <process.h>
#include <stddef.h>
#include <string.h>
#include <sys/kernel.h>
#include <assert.h>

class Thread
{
protected:
    pid_t thread_id_;
    static void wrapper(void* p);
    static const size_t stack_size;
public:
    Thread() : thread_id_(-1) {}
    int start(size_t stk = stack_size);
    int sendmsg(void* msg, size_t mlen,
                void* rcv, size_t rlen);
    virtual void run() = 0;
    virtual ~Thread() {}
};

const size_t Thread::stack_size = 4096;

void Thread::wrapper(void* p)
{
    Thread* self = (Thread*)p;
    self->run();
    _endthread();
}

int Thread::start(size_t stk)
{
    assert(thread_id_ < 0);
    thread_id_ = _beginthread(Thread::wrapper, NULL, stk, this);
    return thread_id_;
}

int Thread::sendmsg(void* msg, size_t mlen, void* rcv, size_t rlen)
{
    assert(thread_id_ >= 0);
    return Send(thread_id_, msg, rcv, mlen, rlen);
}


/* Test thread class --- grabs messages and prints them

   "ERROR" is recognized as a message that means we want ERROR back
   "END" is recognized as a message that means you must exit
 */

class DisplayThread : public Thread
{
private:
    char buffer_[256];           // message buffer
    static const char* ok_response;
    static const char* error_response;
    
    virtual void run();
};

const char* DisplayThread::ok_response = "OK\n";
const char* DisplayThread::error_response = "ERROR\n";

void DisplayThread::run()
{
    pid_t pid;
    while(1)
    {
        const char* response;
        
        if((pid = Receive(0, buffer_, sizeof(buffer_))) < 0)
        {
            printf("ERROR--code %d\n", errno);
            return;
        }
        // make sure it's NUL terminated
        buffer_[sizeof(buffer_)-1] = '\0';
        // check message contents
        if(!strcmp(buffer_, "ERROR"))
            response = error_response;
        else if(!strcmp(buffer_, "END"))
            break;              // response sent below
        else
            response = ok_response;
            
        printf("Got from %d: %s\n", pid, buffer_);
        // send back
        Reply(pid, response, strlen(response)+1);
    }
    // send response and die
    Reply(pid, ok_response, sizeof(ok_response));
}
        

// test
int main()
{
    DisplayThread thread;
    char buffer[256], recv[256];

    if(thread.start() < 0)
    {
        printf("UUURGH! Thread could not start! (%d)\n", errno);
        return 1;
    }

    // print our banner and such
    while(1)
    {
        
        printf("Message to send (END to end): ");
        fgets(buffer, sizeof(buffer), stdin);
        int len = strlen(buffer);
        if(buffer[len-1] == '\n')
        {
            buffer[len-1] = '\0';
            --len;
        }
        thread.sendmsg(buffer, len+1, recv, sizeof(recv));
        printf("Got back: %s", recv);
        if(!strcmp(buffer, "END"))
            break;
    }
    return 0;
}

---