Multithreading and Multicontexting

int tpend()

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

#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);
}

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)

#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;
}

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

#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;
}

*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