The following routines must be applied in the program implementation to use multithreading and multicontexting.

Starting Section

The following functions can be used to start multithread/multicontext.

Implementation Section

ATMI functions are used to implement multithread and multicontext. To use ATMI functions, a user must know whether the context used by the client is the current context.

Ending Section

Multithreading and multicontext are terminated by tpend().

int tpend()

If tpend() is not used, the information of the context and associated threads is not deleted from memory. Use of tpend() is recommended to prevent memory-related problems.

The following are examples of a client program, a server program, and a Makefile.

Client Program

The following is a client program.

/*******************************************************************/
/*               Multi-thread/Multi-context Sample Program         */
/*                                                                 */
/* TmaxSoft Co. / QA                                               */
/* remarks: TOUPPER of Tmax must be started already.               */
/*******************************************************************/

#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       /* The number of maximum contexts*/
#define MAX_CALL           1       
#define NUM_THREADS        2       /* The number of threads that must be created at once*/
#define NUM_CONTEXTS       40       /* The number of contexts to be created in a thread*/

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                        */
/**********************************************************/

Server Program

The following is a server program.

#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

The following is a makefile of a client program.

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

TMAXLIBD = $(TMAXDIR)/lib64

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

#In case of multi_thread / multi_context
CFLAGS = -q64 -O -I$(TMAXDIR) -D_ MULTI_THREAD_TEST_ -D _MULTI_CONTXT_TEST_

#In case of 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)

The Tmax multithread and multicontext server library supports the TCS type but not the USC and RDP types.

The multithread and multicontext server library supports multithreads and provides multicontext functions. Therefore, a single server process can handle service requests from multiple threads, and multiple threads can share a single context to run a service.

The standard Tmax server library does not provide multicontext functions, so a thread created by a user cannot use the APIs provided by the Tmax server library.

The following are the items that must be configured to use the multithread and multicontext server library.

Using multithreads to write a program has various benefits. However, If concurrency and performance are not taken into consideration when writing a program, unexpected operations may occur. In order to write a multithread program, the user must have a deep understanding of potential problems of multithread programming.

The following are the advantages and disadvantages of multithread and multicontext.

The following APIs can be utilized when writing multithread and multicontext server programs.

Related API

Matters to be Considered for Development

The following must be considered when writing a server program.

When APIs, such as tpsetctxt() and tpgetctxt(), are used between a service thread and a user-created thread, the following must be taken into consideration.

In addition to the above points, the following must also be taken into consideration.

The following are examples of a client program, a server program, and a Makefile.

Server Program

The following is a server program.

#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

The following is a server 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)

Environment Configuration

The following is an environment configuration file.

*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

A client calls the "MSERVICE" service. A service routine creates a user-created thread, and the user-created thread shares the context of the service thread and simultaneously requests a service through tpcall().

Server Program

The following is a server program.

#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

Refer to Section 7.3.4, “Makefile”.

Environment Configuration

The following is an environment configuration file.

*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