TCS type server programs consists of the following components:

UCS type server programs consists of the following components:

TCS is usually a 3-tier server process. Tmax system receives requested results and returns the results to clients by scheduling client requests to the appropriate process. Developers only have to develop service routines because Tmax provides main() for TCS type service programs. TCS type programs are developed using specified service names as functions.

The following shows a main() routine and a service routine in TCS.

The following shows a TCS type program:

SDLTOUPPER(TPSVCINFO *msg)
{
        ...
        struct  kstrdata *stdata;
        stdata = (struct kstrdata *)msg->data;
        ...
        for (i = 0; i < stdata->len; i++)
            stdata->sdata[i] = toupper(stdata->sdata[i]);
        ...
        tpreturn(TPSUCCESS,0,(char *)stdata, sizeof(struct kstrdata), TPNOFLAGS);
}

Compared to TCS, which only processes requests from clients, UCS can provide services without client requests. UCS supports TCS to quickly provide services with more features. A UCS program consists of usermain() and a service routine.

The following show a main() routine and a service routine in UCS.

The following is a Tmax configuration file for using UCS type processes:

*DOMAIN
res1        SHMKEY = 66999, MAXUSER = 256

*NODE
tmax       TMAXDIR = "/user/tmax",
           APPDIR  = "/user/tmax/appbin",
           PATHDIR = "/user/tmax/path",
           TLOGDIR = "/user/tmax/log/tlog",
           ULOGDIR = "/user/tmax/log/ulog",
           SLOGDIR = "/user/tmax/log/slog"

*SVRGROUP
svg1        NODENAME = tmax

*SERVER
svr1         SVGNAME = svg1

#UCS type process should add SVRTYPE=UCS.
ucssvr1      SVGNAME = svg1, SVRTYPE = UCS
ucssvr2      SVGNAME = svg1, SVRTYPE = UCS
ucssvr3      SVGNAME = svg1, SVRTYPE = UCS

*SERVICE
TOUPPER      SVRNAME = svr1
TOLOWER      SVRNAME = svr1
DUMY1        SVRNAME = ucssvr1
DUMY2        SVRNAME = ucssvr2

The following is a UCS type program:

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

DUMY1(TPSVCINFO *msg)
{
        printf("svc start!");
        tpreturn(TPSUCCESS, 0, (char *)msg->data, 0, TPNOFLAGS);
}

int usermain(int argc, char *argv[])
{
        ...
        while (1) { 
            jobs = tpschedule(-1);
            cnt++;
            ...
            ret = tpcall("TOUPPER", sbuf, 0, &rbuf, &rlen, TPNOFLAGS);
            if (ret < 0) {
                error processing routine
            }
        }
}

RDP

RDP is a server process based on an improved UCS type process at the kernel level. RDP is designed to regularly send small amounts of data to multiple clients (at least 10 times per second) quickly and efficiently. However, a node can only use a single RDP type server. RDP has the same form as UCS, but has a different configuration and references different libraries during compilation.

The following is a Tmax configuration file for using RDP type processes:

*DOMAIN
tmax1   SHMKEY = 7090, MINCLH = 2, MAXCLH = 2

*NODE
tmax1   TMAXDIR = "/home/navis/tmax",
        APPDIR = "/home/navis/tmax/appbin",
        PATHDIR = "/home/navis/tmax/path",
        TLOGDIR = "/home/navis/tmax/log/tlog",
        ULOGDIR = "/home/navis/tmax/log/ulog",
        SLOGDIR = "/home/navis/tmax/log/slog",
        REALSVR = "real",rscpc = 2

A TCS type server program can be compiled with a general C compiler, which can be used through the shell program created when Tmax is installed or the mksvr utility.

The following shows the process of compiling a server program using a structure buffer or field buffer.

The following are the steps for compiling a TCS type server program in Linux. Each development environment (32 or 64 bit) and platform requires different flags and libraries.

Using a Shell program to compile a server program

When Tmax is installed, sample programs, four Makefiles, and a shell program (Makefile.c, Makefile.sdl, Makefile.pc, Makefile.psdl, and compile) are created in the sample server program directory.

The following is a Makefile (Makefile.sdl) of a Tmax server program that uses a structure buffer but not a database. The name of the program is included in $COMP_TARGET, which is passed when a shell program compiler is used.

# Server makefile

TARGET = $(COMP_TARGET)
APOBJS = $(TARGET).o
SDLFILE = demo.s

#Not use Db
LIBS    = -lsvr -lnodb
#In the case of Solaris, –lsocket –lnsl is added.
#In the case of Oracle, Informix, Db2, and Sybase, 
#-loras, –linfs, –ldb2, and –lsybs are used instead of –lnodb, respectively.

OBJS    = $(APOBJS) $(SDLOBJ) $(SVCTOBJ)

SDLOBJ  = ${SDLFILE:.s=_sdl.o}
SDLC    = ${SDLFILE:.s=_sdl.c}
SVCTOBJ = $(TARGET)_svctab.o

CFLAGS  = -O -I$(TMAXDIR)
#Different CFLAG is used according to development environments (32 or 64 bit) and platforms.
#Solaris 32bit, Compaq, Linux: CFLAGS = -O –I$(TMAXDIR)
#Solaris 64bit: CFLAGS = -xarch=v9 -O –I$(TMAXDIR)
#HP 32bit: CFLAGS = -Ae -O –I$(TMAXDIR)
#HP 64bit: CFLAGS = -Ae +DA2.0W +DD64 +DS2.0 -O –I$(TMAXDIR)
#IBM 32bit: CFLAGS = -q32 –brtl -O –I$(TMAXDIR
#IBM 64bit: CFLAGS = -q64 –brtl -O –I$(TMAXDIR

APPDIR  = $(TMAXDIR)/appbin
SVCTDIR = $(TMAXDIR)/svct
LIBDIR  = $(TMAXDIR)/lib
#In the 64 bit environment, it is $(TMADIR)/lib64.

#
.SUFFIXES : .c

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

#
# server compile
#

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

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

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

$(SDLOBJ):
$(TMAXDIR)/bin/sdlc -i ../sdl/$(SDLFILE)
        $(CC) $(CFLAGS) -c ../sdl/$(SDLC)

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

The following is an example of using a Makefile. svr1, svr2, svr3, fdltest, and sdltest are sample programs created during Tmax installation. For more information, refer to the corresponding Makefile.

$./compile sdl svr1
$./compile c svr2
$./compile c svr3
$./compile pc fdltest
$./compile psdl sdltest

Using the mksvr utility to compile a server program

If the mksvr utility is used, service names are not required when writing the Tmax system configuration file and a service table created through gst is also not required. However, if a structure is used, the structure-standard buffer conversion/reversion program must be created. If a database is used, a precompiled file must be used or an RM file must be specified.

$cfl –i sample.m

$sdlc –i demo.s
$sdlc –c –i demo.s –o tmax.sdl
$mksvr –s SDLTOUPPER,SDLTOLOWER –o svr1 –f svr1.c –S ../sdl/demo_sdl.c

$mksvr –s TOUPPER,TOLOWER –o svr2 –f svr2.c 

$fdlc –c –i demo.s –o tmax.fdl
$mksvr –s FDLTOPPER, FDLTOLOWER –o svr3 –f svr3.c 

$proc iname=fdltest include $TMAXDIR
$mksvr –s FDLINS,FDLSEL,FDLDEL,FDLUPT –o fdltest –f fdltest.c

$mksvr –s SDLINS,SDLSEL,SDLDEL,SDLUPT –o sdltest –f sdltest.c
–S ../sdl/demo_sdl.c –r ORACLE

UCS type server programs are compiled like TCS server programs. However, USC uses the libsvrucs.a (or libsvrucs.so) server library while TCS uses libsvr.a (or libsvr.so). A USC type server program, like a TCS server program, can be compiled with a general C compiler, which can be used through the shell program created when Tmax is installed or the mksvr utility.

The following are the steps for compiling a UCS type server program in Linux. Each development environment (32 or 64 bit) and platform requires different flags and libraries. Because of the similarities in the compilation processes of UCS and TCS, refer to "3.4.1. TCS" for more information.

Using the mksvr utility to compile a server program

If the mksvr utility is used, service names are not required when writing the Tmax system configuration file and a service table created through gst is also not required. However, if a structure is used, the structure-standard buffer conversion/reversion program must be created. If a database is used, a precompiled file must be used or an RM file must be specified.

$cfl –i sample.m
$sdlc –i demo.s
$sdlc –c –i demo.s –o tmax.sdl
$mksvr –s UCSSAMPLE –o ucs_svr –f ucs_svr.c –S ../sdl/demo_sdl.c –t UCS