LinuxQuestions.org

LinuxQuestions.org (/questions/)
-   Programming (https://www.linuxquestions.org/questions/programming-9/)
-   -   conceptual server design question (https://www.linuxquestions.org/questions/programming-9/conceptual-server-design-question-270410/)

Bostonian 12-26-2004 03:45 AM
conceptual server design question
 
Hi Everyone,

I'm currently working on a server software and it's still on a design stage.

In short, here's the server's model: server process starts, then it forks a child processes to listen on each unique ip:port pair configured. Forked processes use create threads to respond to requests. Parent and child processes and threads, all have to share the same in-merory database. The database should be updated sometimes on the fly. Only the parent process can initiate an update. I've got to pause every activity going on in the server while updating. Should it be done with semaphores for each thread and forked child process? WHat is the correct way of doing this?

I'm just starting with Linux devevlopment, so, sorry for questions like there. Try to make better soon.

I would appreciate any help.

Thanks a lot!

cppkid 12-27-2004 12:09 AM
Hi there!
Yup i don't know why but there is no function provided in pthread library to pause a thread, as we have Suspend/Resume system in windows. Solaris also support suspending a thread, but in linux you have to suspend a thread using semaphores. I have written a sort of library for it, you can use it i am sending you the source code for these functions.

Code:
#include "SysThread.h"
#include<iostream.h>
#include<unistd.h>
//_____________________________________________________________________________________________
//_____________________________________________________________________________________________
//_________________________________CONSTRUCTER_________________________________________________
//_____________________________________________________________________________________________
CSysThread::CSysThread()
{
int nRet;

        ThreadFunction = (char (*)(void*))Dummy;
        m_pObjThdFn = NULL;
        m_nState = QUITTED;
        m_nSuspend = 0;
        m_ThdID = 0;
        m_nErr = 0;

        pthread_mutex_init(&m_SuspendMutex,NULL);                // Return Check
        pthread_cond_init(&m_ResumeCond,NULL);                // Return Check

        nRet = pthread_create(&m_ThdID, NULL, ThdFn,this);
        if(nRet != 0)
        {
                m_nErr = 1;
                return;
        }
        m_nState = RESUMED;
        pthread_mutex_lock(&m_SuspendMutex);                // Return Check
        Suspend();
}
//_____________________________________________________________________________________________
//_____________________________________________________________________________________________
//_________________________________DESTRUCTER__________________________________________________
//_____________________________________________________________________________________________
CSysThread::~CSysThread()
{
        if(m_ThdID == 0) return;
        pthread_exit(0);
        m_nState = EXITED;
}

//_____________________________________________________________________________________________
//_____________________________________________________________________________________________
//_____________________________________SUSPEND_________________________________________________
//_____________________________________________________________________________________________
int CSysThread::Suspend()
{
        cout<<"Suspending........\n";

        if(IsThdSuspended()) return 0;        // Alredy Suspended

        m_nSuspend = 1;
        return 1;
}
//_____________________________________________________________________________________________
//_____________________________________________________________________________________________
//______________________________________RESUME_________________________________________________
//_____________________________________________________________________________________________
int CSysThread::Resume(char (*func)(void*), void *pObj)
{
int nCondRet;

        if(IsThdSuspended() == false) return -1;

        m_pObjThdFn = pObj;
        ThreadFunction = (char (*)(void*))func;
        nCondRet = pthread_cond_signal(&m_ResumeCond);
        if(nCondRet != 0) return -1;
        return 1;
}
//_____________________________________________________________________________________________
//_____________________________________________________________________________________________
//______________________________________IsSuspended____________________________________________
//_____________________________________________________________________________________________

int CSysThread::IsSuspended()
{
        return m_nState;
}

bool CSysThread::IsThdSuspended()
{
int nRet;

        nRet = pthread_mutex_trylock(&m_SuspendMutex);
        if(nRet == 0)        // Thread was suspended
        {
                nRet = pthread_mutex_unlock(&m_SuspendMutex);
                return true;
        }
        return false;
}
//_____________________________________________________________________________________________
//_____________________________________________________________________________________________
//_________________________________________GetErr______________________________________________
//_____________________________________________________________________________________________
int CSysThread::GetErr()
{
        return m_nErr;
}
//_____________________________________________________________________________________________
//_____________________________________________________________________________________________
//_________________________________________GetThreadID______________________________________________
//_____________________________________________________________________________________________
unsigned long CSysThread::GetThreadID()
{
        return m_ThdID;
}
//_____________________________________________________________________________________________
//_____________________________________________________________________________________________
//_________________________________________TerminateSysThread__________________________________
//_____________________________________________________________________________________________
int CSysThread::TerminateSysThread()
{
        pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,NULL);
        pthread_cancel(m_ThdID);
        m_nState = EXITED;
        return 1;
}
//_____________________________________________________________________________________________
//_____________________________________________________________________________________________
//_________________________________________Quit________________________________________________
//_____________________________________________________________________________________________
int CSysThread::Quit()
{
int nRet;

        if(m_ThdID == 0) return -1;
        pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,NULL);
        nRet = pthread_cancel(m_ThdID);
        m_nState = EXITED;
        return nRet;
}

//_____________________________________________________________________________________________
//_____________________________________________________________________________________________
//_____________________________________________ThdFn___________________________________________
//_____________________________________________________________________________________________

void* CSysThread::ThdFn(void *ptr)
{
char ch;
int nSuspRet;
CSysThread *pCthd = (CSysThread*)ptr;

        pthread_cleanup_push(&CallBack,pCthd);}

        while(1)
        {

                if(pCthd->m_nSuspend==1)
                {
                        pCthd->m_nSuspend = 0;
                        pCthd->m_nState = SUSPENDED;
                        pthread_cond_wait(&pCthd->m_ResumeCond,&pCthd->m_SuspendMutex);
                }
                pCthd->m_nState = RESUMED;
                usleep(2000);
                // check if the funtion is exited, Call the thread cancelation
                ch = (*(pCthd->ThreadFunction))(pCthd->m_pObjThdFn);
                if(ch < 0)
                {
                        nSuspRet = pCthd->Suspend();
                        if(nSuspRet < 0)
                        {
                                pthread_exit(0);
                                pCthd->m_nState = EXITED;
                        }
                }
        }
}

//_____________________________________________________________________________________________
//_____________________________________________________________________________________________
//_____________________________________________CallBack___________________________________________
//_____________________________________________________________________________________________

void CSysThread::CallBack(void *ptr)
{
CSysThread *pCthd = (CSysThread*)ptr;

        pCthd->m_nState = QUITTED;
        pCthd->m_ThdID = 0;
}
//_____________________________________________________________________________________________
//_____________________________________________________________________________________________
//_____________________________________________CallBack___________________________________________
//_____________________________________________________________________________________________
char CSysThread::Dummy(void *arg)
{
        sleep(1);
        return 1;
}

cppkid 12-27-2004 12:13 AM
Sorry i forgot to send the header file for SysThread Lib so here it is,

Code:
#include<pthread.h>

#define SUSPENDED        1
#define EXITED                2
#define RESUMED                3
#define QUITTED                4

class CSysThread
{
private:
        pthread_mutex_t        m_SuspendMutex;
        pthread_cond_t        m_ResumeCond;
        int m_nSuspend;
        int m_nState;
        pthread_t m_ThdID;
        void *m_pObjThdFn;
        char (*ThreadFunction)(void *);
        static char Dummy(void *arg);
        static void CallBack(void *arg);
        bool IsThdSuspended();
       
protected:
        int m_nErr;

        public:
        static void *ThdFn(void *pObj);
        int Suspend(void);
        int Resume(char (*)(void*), void *);
        int IsSuspended();
        int GetErr();
        unsigned long GetThreadID();
        int Quit();
        int TerminateSysThread();
       
        // Constructer / Destructer
        CSysThread();
        virtual ~CSysThread();
};

Bostonian 12-27-2004 02:22 AM
That's exactly what I wanted.

Thanks a lot.


All times are GMT -5. The time now is 06:48 AM.