Multithread와 Multicontext를 사용하기 위해서는 다음의 3가지 루틴을 따라 클라이언트 프로그램을 작성해야 한다.

시작 구문

Multithread 및 Multicontext는 다음의 함수로 시작할 수 있다.

구현 구문

Multithread 및 Multicontext는 ATMI 함수들을 사용하여 구현한다. ATMI 함수들을 사용할 때는 반드시 현재 context인지를 알고 사용해야 정상적으로 사용할 수 있다.

종료 구문

tpend() 함수를 통하여 Multithread 및 Multicontext를 종료한다.

int tpend()

이 함수를 사용하지 않는 경우 context와 해당하는 스레드에 대한 정보가 메모리에서 지워지지 않아서 나중에 문제가 발생할 수 있으므로, 반드시 context를 사용한 후에는 tpend()를 해 주어야 한다.

클라이언트 프로그램, 서버 프로그램, Makefile의 예제를 설명한다.

클라이언트 프로그램

다음은 클라이언트 프로그램의 예제이다.

/*******************************************************************/
/*               Multi-thread/Multi-context Sample Program         */
/*                                                                 */
/* TmaxSoft Co. / QA                                               */
/* remarks: Tmax의 TOUPPER 서비스가 구동되어 있어야 함.            */
/*******************************************************************/

#include       <pthread.h>
#include        <stdlib.h>
#include        <stdio.h>
#include        <errno.h>
#include        <string.h>
#include        <unistd.h>
#include        <netdb.h>
#include        <sys/types.h>
#include       <usrinc/atmi.h>

#define MAX_CTID_CNT       400       /* 최대 context 수*/
#define MAX_CALL           1       
#define NUM_THREADS        2       /* 한 번에 생성할 스레드 수*/
#define NUM_CONTEXTS       40       /* 한 스레드에서 생성할 context 수*/

void *mythread(void *arg);
int svcCall(char* svc, char* arg);

int newContext();
int altContext(int id);
int delContext();

#define CTID_EMPTY       0
#define       CTID_OCCUPIED       1
#define THRERR   (void *)-1
#define THRSUC   (void *)1

extern int errno;
extern int _init_wthr_flag;
int           thr_id;
TPSTART_T* tpinfo;

int main()
{
        void      *retVal;
        char      argData[100];
        int       tcnt = 0;
        int       scnt = 0;
               
        pthread_t   p_thread[NUM_THREADS];        

        memset(argData, 0x00, sizeof(argData));
        strcpy(argData,"...mtmc test...");
       
       if (tmaxreadenv("tmax.env","TMAX") == -1)
       {
              printf( "tmax read env failed\n" );
              return FALSE;
       }       
    
        tpinfo = (TPSTART_T *)tpalloc("TPSTART", NULL, 0);
        if (tpinfo == NULL) 
        {
               printf("[THR:%d]tpinfo tpalloc fail[%d][%s]\n",pthread_self(), 
                      tperrno,tpstrerror(tperrno));
        }
        
#ifdef _MULTI_THREAD_TEST_  
        
       while(scnt<MAX_CALL) 
       {
               for ( tcnt=0 ; tcnt<NUM_THREADS ; tcnt++)
               {       
                     if (pthread_create(&p_thread[tcnt], NULL, mythread,argData))
                      {
                             fprintf(stderr, "mythread start fail...[%d]\n", errno);
                             return FALSE;
                      }
               }
        
                for(tcnt=0 ; tcnt<NUM_THREADS ; tcnt++)
                {
                       pthread_join(p_thread[tcnt], &retVal);
                }
                
                scnt++;
                sleep(1);
        }
        
#else
       
       if (pthread_create(&p_thread[tcnt], NULL, mythread, argData))
       {  
               fprintf(stderr, "mythread start fail...[%d]\n", errno);
               return FALSE;
       }
             pthread_join(p_thread[tcnt], &retVal);
             
#endif            
       
        tpfree((char *)tpinfo);
        return TRUE;
}


/**********************************************************/
/* Sub Process : myhread                                  */
/**********************************************************/
void *mythread(void *arg)
{
       int i,j,k;

printf("[THR:%d] thread start\n",pthread_self());

#ifdef _MULTI_CONTXT_TEST_
        tpinfo->flags = TPMULTICONTEXTS;
        for(i=0;i<NUM_CONTEXTS/2;i++)
       {
              j=newContext();
              k=newContext();

              svcCall("TOUPPER",arg);
              delContext();
               
               altContext(j);
               svcCall("TOUPPER",arg);
               delContext();
               
       }
        
#else
       tpinfo->flags = TPSINGLECONTEXT;
       newContext();
       svcCall("TOUPPER",arg);
       delContext();
       
#endif
                
printf("[THR:%d] thread finish\n",pthread_self());

        return THRSUC;
}


/**********************************************************/
/* Sub Process : delContext                               */
/**********************************************************/
int delContext()
{
      int i;
      int id;
       
      i = tpgetctxt(&id,TPNOFLAGS);
        
      if (i < 0) 
      {
          printf("\t[delContext]tpgetctxt fail[%d][%s]\n",
                  tperrno,tpstrerror(tperrno));
          return -1;
      }
        
      tpend();
      printf("\t[THR:%d][CTXT:%d]tpend.\n",pthread_self(),id); 
      return 1;
}

/**********************************************************/
/* Sub Process : newContext                               */
/**********************************************************/
int newContext()
{
       int i;
       int id;
       
       i = tpstart(tpinfo);
       
        if (i < 0)
        {
                printf("\t[newContext]tpstart fail[%d][%s]\n", tperrno, 
                       tpstrerror(tperrno));
                tpfree((char *)tpinfo);
                return -1;
        }
        
        i = tpgetctxt(&id,TPNOFLAGS);
        
        if (i < 0) 
        {
               printf("\t[newContext]tpgetctxt fail[%d][%s]\n", tperrno, 
                       tpstrerror(tperrno));
               return -1;
        } 
        return id;
}

/**********************************************************/
/* Sub Process : altContext                               */
/**********************************************************/
int altContext(int id)
{
       int i;
       int ret;

       ret = tpsetctxt(id, TPNOFLAGS);
        
       if (ret < 0)
       {
           printf("\t[altContext]tpsetctxt fail[%d][%s]\n",  tperrno,
                  tpstrerror(tperrno));
           tpfree((char *)tpinfo);
           return -1;
       }
       
       return 1;
}

/**********************************************************/
/* Sub Process : svcCall                                  */
/**********************************************************/
int svcCall(char* svc, char* arg)
{
       int ret;
       long rlen;
       char *sbuf, *rbuf;
       int  id;
       
       ret=tpgetctxt(&id,TPNOFLAGS);
       
       sbuf = (char *)tpalloc("STRING", NULL, 0);       
        if (sbuf == NULL)
        {
               printf("\t[svrCall]tpalloc error[%d][%s]\n",tperrno, 
                      tpstrerror(tperrno));
               return -1;
        }
        
        rbuf = (char *)tpalloc("STRING", NULL, 0);       
        if (rbuf == NULL)
        {
               printf("\t[svrCall]tpalloc error[%d][%s]\n",tperrno, 
                      tpstrerror(tperrno));
               return -1;
        }
        
        strcpy(sbuf, (char *)arg);
        
        ret = tpcall(svc, (char *)sbuf, strlen(arg), (char **)&rbuf, (long *)&rlen, 
                     TPNOFLAGS);
        
        if (ret < 0)
        {
               printf("\t[svcCall]tpcall fail.[%d][%s]\n",tperrno, 
                      tpstrerror(tperrno));
        }
        else
        {
              printf("\t[THR:%d][CTXT:%d]tpcall success.\n",pthread_self(),id); 
        }
        
        tpfree((char *)sbuf);
        tpfree((char *)rbuf);        
}
/**********************************************************/
/*                             END                        */
/**********************************************************/

서버 프로그램

다음은 서버 프로그램의 예제이다.

#include <stdio.h>
#include <usrinc/atmi.h>

TOUPPER(TPSVCINFO *msg)
{
        int  i;

        printf("\tTOUPPER service is started!\n");
        printf("\tINPUT : data=%s\n", msg->data);

        for (i = 0; i < msg->len; i++)
             msg->data[i] = toupper(msg->data[i]);

        printf("\tOUTPUT: data=%s\n", msg->data);

        tpreturn(TPSUCCESS,0,(char *)msg->data, 0,0);
}

Makefile

다음은 클라이언트 프로그램의 Makefile 예제이다.

TARGET = $(COMP_TARGET)
APOBJS = $(TARGET).o

TMAXLIBD = $(TMAXDIR)/lib64

TMAXLIBS = -lcli
#TMAXLIBS =/home/ancestor/tmax/lib/libclid.a

#multi_thread / multi_context 일 경우
CFLAGS = -q64 -O -I$(TMAXDIR) -D_ MULTI_THREAD_TEST_ -D _MULTI_CONTXT_TEST_

#single_thread / multi_context 일 경우
CFLAGS = -q64 -O -I$(TMAXDIR) -D _MULTI_CONTXT_TEST_

LDFLAGS = -brtl

#
.SUFFIXES : .c

.c.o: 
       $(CC) $(CFLAGS) $(LDFLAGS) -c $<

#
# client compile
#
$(TARGET): $(APOBJS)
       $(CC) $(CFLAGS) $(LDFLAGS) -L$(TMAXLIBD) -o $(TARGET) $(APOBJS) $(TMAXLIBS) 

#
clean:
       -rm -f *.o core $(TARGET)

Tmax Multithread와 Multicontext 서버 라이브러리는 TCS 방식의 서버 라이브러리에 대해서는 지원하나 UCS, RDP 라이브러리는 지원하지 않는다.

Multithread와 Multicontext 서버 라이브러리는 Multithread 지원 및 Multicontext 기능을 제공한다. 따라서 하나의 서버 프로세스에서 여러 스레드가 서비스 요청을 동시에 처리하거나 2개 이상의 스레드가 하나의 context를 공유하면서 서비스를 처리할 수 있다.

일반적인 Tmax 서버 라이브러리는 Multicontext 기능을 제공하지 않기 때문에 사용자가 생성한 스레드에서는 Tmax 서버 라이브러리가 제공하는 API들을 사용할 수 없다.

Multithread와 Multicontext 서버 라이브러리를 사용하려면 다음과 같은 사항을 설정해야 한다.

Multithread를 이용한 프로그래밍은 여러 측면에서 매우 유용한 점을 가지고 있다. 하지만 동시성이나 성능적인 측면 등에서 주의 깊게 코드를 작성하지 않으면 개발자가 원하지 않는 동작을 유발할 수 있다. 따라서 Multithread 프로그래밍이 가지는 잠재적인 문제점을 잘 이해해야 한다.

Multithread와 Multicontext를 서버 라이브러리를 사용할 경우 다음의 장/단점을 갖는다.

Multithread와 Multicontext 서버 프로그램을 작성할 경우 다음의 API를 활용하여 개발할 수 있다. 개발자는 주의사항을 참고하여 서버 프로그램을 작성한다.

관련 API

서버 프로그램을 작성할 경우 관련 API는 다음과 같다.

개발 시 주의사항

개발자는 서버 프로그램을 작성할 때 다음과 같은 사항들을 주의 깊게 살펴야한다.

서비스 스레드와 사용자 생성 스레드 사이에서 tpsetctxt(), tpgetctxt() 등의 API를 사용할 경우 아래의 사항을 반드시 지켜야 한다.

다음은 앞에서 언급한 내용 이외에 주의해야 할 사항이다.

클라이언트 프로그램, 서버 프로그램, Makefile의 예제를 설명한다.

서버 프로그램

다음은 서버 프로그램의 예제이다.

#include <stdio.h>
#include <usrinc/tmaxapi.h>

int tpsvrinit(int argc, char **argv)
{
        printf("tpsvrinit()");
        return 1;
}

int tpsvrthrinit(int argc, char **argv)
{
        printf("tpsvrthrinit()");
        return 1;
}

MTOUPPER(TPSVCINFO *msg)
{
        int i;
        printf("MTOUPPER service is started!");
        for (i = 0; i < msg->len; i++)
        msg->data[i] = toupper(msg->data[i]);
        tpreturn(TPSUCCESS,0,msg->data, 0, 0);
}

MTOLOWER(TPSVCINFO *msg)
{
        int i;
        printf("MTOLOWER service is started!");
        for (i = 0; i < msg->len; i++)
        msg->data[i] = tolower(msg->data[i]);
        tpreturn(TPSUCCESS,0,msg->data, 0, 0);
}

int tpsvrthrdone()
{
        printf("tpsvrthrdone()");
        return 1;
}

int tpsvrdone()
{
        printf("tpsvrdone()");
        return 1;
}

Makefile

다음은 서버 Makefile의 예제이다.

TARGET = $(COMP_TARGET)
APOBJS = $(TARGET).o
NSDLOBJ = $(TMAXDIR)/lib/sdl.o

LIBS = -lsvrmt -lnodb
OBJS = $(APOBJS) $(SVCTOBJ)
SVCTOBJ = $(TARGET)_svctab.o

CFLAGS = -I$(TMAXDIR) -D_MCONTEXT

APPDIR = $(TMAXDIR)/appbin
SVCTDIR = $(TMAXDIR)/svct
LIBDIR = $(TMAXDIR)/lib

#
.SUFFIXES : .c

.c.o:
        $(CC) $(CFLAGS) -c $<

#
# server compile
#

$(TARGET): $(OBJS)
        $(CC) $(CFLAGS) -L$(LIBDIR) -o $(TARGET) $(OBJS) $(LIBS) $(NSDLOBJ)
        mv $(TARGET) $(APPDIR)/.
        cp $(TARGET).c $(APPDIR)/.
        rm -f $(OBJS)

$(APOBJS): $(TARGET).c
        $(CC) $(CFLAGS) -c $(TARGET).c


$(SVCTOBJ):
        cp -f $(SVCTDIR)/$(TARGET)_svctab.c .
        touch ./$(TARGET)_svctab.c
        $(CC) $(CFLAGS) -c ./$(TARGET)_svctab.c

clean:
        -rm -f *.o core $(APPDIR)/$(TARGET)

환경설정

다음은 환경설정 파일의 예제이다.

*DOMAIN
tmax1   SHMKEY = 77214, MINCLH = 1, MAXCLH = 1,
        TPORTNO = 8888, BLOCKTIME = 30, MAXCACALL = 1024

*NODE
tmax    TMAXDIR = "/home/test/tmax",
        APPDIR = "/home/test/tmax/appbin",
        PATHDIR = "/home/test/tmax/path",
        TLOGDIR = "/home/test/tmax/log/tlog",
        ULOGDIR = "/home/test/tmax/log/ulog",
        SLOGDIR = "/home/test/tmax/log/slog",
        MAXCPC = 200

*SVRGROUP
svg1    NODENAME = tmax

*SERVER
svrmt1  SVGNAME = svg1, SVRTYPE = "STD_MT",
        MIN = 1, MAX = 1,
        CPC = 10, MINTHR = 5, MAXTHR = 10

*SERVICE
MTOUPPER SVRNAME = svrmt1, SVCTIME = 20
MTOLOWER SVRNAME = svrmt1, SVCTIME = 20

클라이언트에서 "MSERVICE" 서비스를 호출한다. 서비스 루틴에서는 사용자 생성 스레드를 생성하고, 사용자 스레드가 서비스 스레드의 context를 공유한 뒤, 동시에 tpcall()을 통해 서비스를 요청하는 방식으로 동작한다.

서버 프로그램

다음은 서버 프로그램의 예제이다.

#include <stdio.h>
#include <string.h>
#include <pthread.h>
#include <usrinc/tmaxapi.h>

void * THREAD(void *arg);

typedef struct {
        int ctxtid;
        TPSVCINFO *svcinfo;
} param_t;

int testcall(char *service, char *msg, long flags)
{
        char *sndbuf, *rcvbuf;
        long sndlen, rcvlen;

        sndlen = strlen(msg);
        if((sndbuf = (char *) tpalloc("STRING", NULL, sndlen)) == NULL) {
                printf("Error allocating send buffer, [tperrno:%d]", tperrno);
                return -1;
        }
        if((rcvbuf = (char *) tpalloc("STRING", NULL, 0)) == NULL) {
                printf("Error allocating recv buffer, [tperrno:%d]", tperrno);
                tpfree(sndbuf);
                return -1;
        }

        strcpy(sndbuf, msg);
        if(tpcall(service, sndbuf, sndlen, (char **)&rcvbuf, &rcvlen, flags) == -1)
                printf("tpcall(%s) failed, [tperrno:%d, tpurcode:%d]", service, tperrno, tpurcode);
        else
                printf("tpcall(%s) success, [rcvbuf:%s]", service, rcvbuf);

        tpfree(sndbuf);
        tpfree(rcvbuf);
        return 0;
}

MTOUPPER(TPSVCINFO *svcinfo)
{
        int i;

        printf("MTOUPPER service is started! [len:%d, data:%s]\n", svcinfo->len, svcinfo->data);

        for (i = 0; i < svcinfo->len; i++)
                svcinfo->data[i] = toupper(svcinfo->data[i]);

        sleep(1);
        printf("MTOUPPER service is finished!\n");
        tpreturn(TPSUCCESS, 0, svcinfo->data, 0, 0);
}

MTOLOWER(TPSVCINFO *svcinfo)
{
        int i;.

        printf("MTOLOWER service is started! [len:%d, data:%s]\n", svcinfo->len, svcinfo->data);
        for (i = 0; i < svcinfo->len; i++)
                svcinfo->data[i] = tolower(svcinfo->data[i]);

        sleep(1);
        printf("MTOLOWER service is finished!\n");
        tpreturn(TPSUCCESS, 0, (char *)svcinfo->data, 0, 0);
}

MSERVICE(TPSVCINFO *svcinfo)
{
        pthread_t tid;
        param_t param;

        printf("MSERVICE service is started!");

        tpgetctxt(&param.ctxtid, 0);
        param.svcinfo = svcinfo;
        pthread_create(&tid, NULL, THREAD, &param);

        testcall("MTOLOWER", svcinfo->data, 0);

        pthread_join(tid, NULL);
        printf("MSERVICE service is finished!");
        tpreturn(TPSUCCESS, 0, svcinfo->data, 0L, 0);
}

void *THREAD(void *arg)
{
        param_t *param;
        TPSVCINFO *svcinfo;

        param = (param_t *)arg;
        svcinfo = param->svcinfo;

        if (tpsetctxt(param->ctxtid, 0) == -1) {
                printf("tpsetctxt(%d) failed, [tperrno:%d]", param->ctxtid, tperrno);
                return NULL;
        }

        testcall("MTOUPPER", svcinfo->data, 0);

        if (tpsetctxt(TPNULLCONTEXT, 0) == -1) {
                printf("tpsetctxt(TPNULLCONTEXT) failed, [tperrno:%d]", tperrno);
                return NULL;
        }
        return NULL;
}

int tpsvrinit(int argc, char *argv[])
{
        printf("do tpsvrinit()");
        return 1;
}

int tpsvrthrinit(int argc, char *argv[])
{
        printf("do tpsvrthrinit()");
        return 1;
}

int tpsvrthrdone(void)
{
        printf("do tpsvrthrdone()");
        return 1;
}

int tpsvrdone(void)
{
        printf("do tpsvrdone()");
        return 1;
}

Makefile

절 7.3.4. “Makefile”을 참고한다.

환경설정

다음은 환경설정 파일의 예제이다.

*DOMAIN
tmax1   SHMKEY = 77214, MINCLH = 1, MAXCLH = 1,
        TPORTNO = 8888, BLOCKTIME = 30, MAXCACALL = 1024

*NODE
tmax    TMAXDIR = "/home/test/tmax",
        APPDIR = "/home/test/tmax/appbin",
        PATHDIR = "/home/test/tmax/path",
        TLOGDIR = "/home/test/tmax/log/tlog",
        ULOGDIR = "/home/test/tmax/log/ulog",
        SLOGDIR = "/home/test/tmax/log/slog",
        MAXCPC = 200

*SVRGROUP
svg1    NODENAME = tmax

*SERVER
svrmt2  SVGNAME = svg1, SVRTYPE = "STD_MT",
        MIN = 1, MAX = 1,
        CPC = 10, MINTHR = 5, MAXTHR = 10

*SERVICE
MSERVICE SVRNAME = svrmt2, SVCTIME = 10
MTOUPPER SVRNAME = svrmt2
MTOLOWER SVRNAME = svrmt2