int main(int argc, char *argv[]) {
bool chook = false;
int client = false;
int dinx;
int disable;
int ferr;
int inx;
char lname[10];
bool mq = false;
int oid;
void *res;
bool rnd = false;
int sleept;
int snid;
int spid;
int status;
TAD zargs[] = {
{ "-chook", TA_Bool, TA_NOMAX, &chook },
{ "-client", TA_Bool, TA_NOMAX, &client },
{ "-dloop", TA_Int, MAX_OUT, &gdloop },
{ "-dsize", TA_Int, TA_NOMAX, &gdsize },
{ "-ksleep", TA_Int, TA_NOMAX, &gksleep },
{ "-loop", TA_Int, TA_NOMAX, &gloop },
{ "-maxc", TA_Int, MAX_THR, &gmaxc },
{ "-maxs", TA_Int, MAX_THR, &gmaxs },
{ "-mq", TA_Bool, TA_NOMAX, &mq },
{ "-nodecycle", TA_Bool, TA_NOMAX, &gnodecycle },
{ "-rnd", TA_Bool, TA_NOMAX, &rnd },
{ "-server", TA_Ign, TA_NOMAX, NULL },
{ "-v", TA_Bool, TA_NOMAX, &gverbose },
{ "-vpp", TA_Bool, TA_NOMAX, &gverbosepp },
{ "", TA_End, TA_NOMAX, NULL }
};
arg_proc_args(zargs, false, argc, argv);
if (client && chook)
test_debug_hook("c", "c");
msfs_util_init(&argc, &argv, msg_debug_hook);
util_test_start(client);
if (!client)
setup_sig();
ferr = msg_mon_process_startup(true); // system messages
TEST_CHK_FEOK(ferr);
gargc = argc; // after msg_init - it removes args
gargp = argv;
sprintf(gprog, "%s/%s", getenv("PWD"), argv[0]);
gvirtual = (getenv("SQ_VIRTUAL_NODES") != NULL);
ferr = msg_mon_get_my_process_name(gname, sizeof(gname));
assert(ferr == XZFIL_ERR_OK);
if (client) {
msg_mon_enable_mon_messages(true); // get mon messages
ferr = msg_mon_get_process_info(NULL, &gcnid, NULL);
assert(ferr == XZFIL_ERR_OK);
ferr = XCONTROLMESSAGESYSTEM(XCTLMSGSYS_SETSENDLIMIT,
(short) (gmaxc * gdloop));
assert(ferr == XZFIL_ERR_OK);
srand(1);
sleept = 1000;
start_server(argc, argv);
sleep(1);
ferr = msg_mon_open_process((char *) "$srv", // name
TPT_REF(gphandle),
&oid);
TEST_CHK_FEOK(ferr);
ferr = XPROCESSHANDLE_DECOMPOSE_(TPT_REF(gphandle), &snid, &spid);
TEST_CHK_FEOK(ferr);
for (inx = 0; inx < gloop; inx++) {
if (mq)
printf("client: inx=%d\n", inx);
for (dinx = 0; dinx < gmaxc; dinx++) {
sprintf(lname, "c%d", dinx);
gthrc[dinx] = new MyThread(client_thr, lname, dinx);
}
disable = msg_test_assert_disable();
for (dinx = 0; dinx < gmaxc; dinx++)
gthrc[dinx]->start();
if (rnd)
sleept = (int) ((float) gksleep * (rand_r(&gseed) / (RAND_MAX + 1.0)));
usleep(sleept);
for (dinx = 0; dinx < gmaxc; dinx++) {
status = gthrc[dinx]->join(&res);
TEST_CHK_STATUSOK(status);
if (gverbose)
printf("joined with client %d\n", dinx);
}
for (dinx = 0; dinx < gmaxc; dinx++)
delete gthrc[dinx];
msg_test_assert_enable(disable);
}
} else {
msg_mon_enable_mon_messages(true); // get mon messages
ferr = XCONTROLMESSAGESYSTEM(XCTLMSGSYS_SETRECVLIMIT,
XMAX_SETTABLE_RECVLIMIT);
assert(ferr == XZFIL_ERR_OK);
pp_init();
if (!gshutdown) {
for (dinx = 0; dinx < gmaxs; dinx++) {
char lname[10];
sprintf(lname, "s%d", dinx);
gthrs[dinx] = new SB_Thread::Thread(server_thr, lname);
}
for (dinx = 0; dinx < gmaxs; dinx++)
gthrs[dinx]->start();
for (dinx = 0; dinx < gmaxs; dinx++) {
status = gthrs[dinx]->join(&res);
TEST_CHK_STATUSOK(status);
if (gverbose)
printf("joined with server %d\n", dinx);
}
}
if (gverbosepp)
pp_printf("exit pid=%d\n", getpid());
}
if (client) {
sleep(1);
ferr = msg_mon_close_process(TPT_REF(gphandle));
TEST_CHK_FEOK(ferr);
}
ferr = msg_mon_process_shutdown();
TEST_CHK_FEOK(ferr);
util_test_finish(client);
return 0;
}
Int32 runESP(Int32 argc, char** argv, GuaReceiveFastStart *guaReceiveFastStart)
{
// initialize ESP global data
StatsGlobals * statsGlobals;
XCONTROLMESSAGESYSTEM(XCTLMSGSYS_SETRECVLIMIT, XMAX_SETTABLE_RECVLIMIT_H);
CliGlobals *cliGlobals = NULL;
cliGlobals = CliGlobals::createCliGlobals(TRUE); // TRUE indicates a non-master process (WAIT on LREC)
if (cliGlobals == NULL) // Sanity check
NAExit(1); // Abend
Int32 shmid;
statsGlobals = shareStatsSegment(shmid);
cliGlobals->setSharedMemId(shmid);
//Lng32 numCliCalls = cliGlobals->incrNumOfCliCalls();
cliGlobals->setIsESPProcess(TRUE);
NAHeap *espExecutorHeap = cliGlobals->getExecutorMemory();
// must create default context after set IpcEnvironment in CliGlobals first
// because context's ExSqlComp object needs IpcEnvironment
cliGlobals->initiateDefaultContext();
NAHeap *espIpcHeap = cliGlobals->getIpcHeap();
IpcEnvironment *ipcEnvPtr = cliGlobals->getEnvironment();
if (statsGlobals != NULL)
cliGlobals->setMemoryMonitor(statsGlobals->getMemoryMonitor());
else
{
// Start the memory monitor for dynamic memory management
Lng32 memMonitorWindowSize = 10;
Lng32 memMonitorSampleInterval = 10;
MemoryMonitor *memMonitor = new (espExecutorHeap)
MemoryMonitor(memMonitorWindowSize,
memMonitorSampleInterval,
espExecutorHeap);
cliGlobals->setMemoryMonitor(memMonitor);
}
// After CLI globals are initialized but before we begin ESP message
// processing, have the CLI context set its user identity based on
// the OS user identity.
ContextCli *context = cliGlobals->currContext();
ex_assert(context, "Invalid context pointer");
context->initializeUserInfoFromOS();
ExEspFragInstanceDir espFragInstanceDir(cliGlobals,
espExecutorHeap,
(StatsGlobals *)statsGlobals);
ExEspControlMessage espIpcControlMessage(&espFragInstanceDir,
ipcEnvPtr,
espIpcHeap);
// handle startup (command line args, control connection)
DoEspStartup(argc,argv,*ipcEnvPtr,espFragInstanceDir,guaReceiveFastStart);
// the control message stream talks through the control connection
espIpcControlMessage.addRecipient(
ipcEnvPtr->getControlConnection()->getConnection());
// start the first receive operation
espIpcControlMessage.receive(FALSE);
NABoolean timeout;
Int64 prevWaitTime = 0;
// while there are requesters
while (espFragInstanceDir.getNumMasters() > 0)
{
// -----------------------------------------------------------------
// The ESPs most important line of code: DO THE WORK
// -----------------------------------------------------------------
espFragInstanceDir.work(prevWaitTime);
// -----------------------------------------------------------------
// After we have done work, it's necessary to wait for some I/O
// (the frag instance dir work procedure works until it is blocked).
// -----------------------------------------------------------------
ipcEnvPtr->getAllConnections()->
waitOnAll(IpcInfiniteTimeout, TRUE, &timeout, &prevWaitTime); // TRUE means: Called by ESP main
}
// nobody wants us anymore, right now that means that we stop
return 0;
}
int main(int argc, char *argv[]) {
_bcc_status bcc;
void *buf;
int cancel = 0;
bool client = false;
int closes;
int count;
int count_cancel;
int count_read;
int count_written;
int count_xferred;
int ferr;
int inxl;
int inxo;
int inxs;
int inxx;
int loop = 10;
int maxcp = 1;
int maxout = 1;
int maxsp = 1;
int msg_count;
bool mq = false;
short filenumr;
short filenums[MAX_SRV];
int send_len;
char serv[20];
xzsys_ddl_smsg_def *sys_msg = (xzsys_ddl_smsg_def *) recv_buffer;
SB_Tag_Type tago;
short tfilenum;
int timeout = -1;
bool verbose = false;
TAD zargs[] = {
{ "-cancel", TA_Int, TA_NOMAX, &cancel },
{ "-client", TA_Bool, TA_NOMAX, &client },
{ "-loop", TA_Int, TA_NOMAX, &loop },
{ "-maxcp", TA_Int, MAX_CLI, &maxcp },
{ "-maxout", TA_Int, MAX_OUT, &maxout },
{ "-maxsp", TA_Int, MAX_SRV, &maxsp },
{ "-mq", TA_Bool, TA_NOMAX, &mq },
{ "-server", TA_Ign, TA_NOMAX, NULL },
{ "-v", TA_Bool, TA_NOMAX, &verbose },
{ "", TA_End, TA_NOMAX, NULL }
};
ferr = file_init(&argc, &argv);
TEST_CHK_FEOK(ferr);
msfs_util_init_fs(&argc, &argv, file_debug_hook);
arg_proc_args(zargs, false, argc, argv);
util_test_start(client);
ferr = file_mon_process_startup(!client); // system messages?
TEST_CHK_FEOK(ferr);
ferr = msg_mon_get_my_process_name(my_name, BUFSIZ);
util_check("file_mon_get_my_process_name", ferr);
if (client) {
ferr = XCONTROLMESSAGESYSTEM(XCTLMSGSYS_SETSENDLIMIT,
XMAX_SETTABLE_SENDLIMIT);
assert(ferr == XZFIL_ERR_OK);
for (inxs = 0; inxs < maxsp; inxs++) {
sprintf(serv, "$srv%d", inxs);
ferr = BFILE_OPEN_(serv, (short) strlen(serv), &filenums[inxs],
0, 0, (short) maxout,
0, 0, 0, 0, NULL);
TEST_CHK_FEOK(ferr);
}
msg_count = 0;
count_cancel = 0;
for (inxl = 0; inxl < loop; inxl++) {
count = 0;
if (cancel)
count_cancel = rnd(cancel);
for (inxs = 0; inxs < maxsp; inxs++) {
for (inxo = 0; inxo < maxout; inxo++) {
send_len = rnd(BUFSIZ);
bcc = BWRITEREADX(filenums[inxs],
send_buffer[inxo],
send_len,
BUFSIZ,
&count_read,
inxo + 1);
out_list[inxs][inxo] = inxo + 1;
util_check("BWRITEREADX", ferr);
}
}
for (inxs = 0; inxs < maxsp; inxs++) {
for (inxo = 0; inxo < maxout; inxo++) {
msg_count++;
if (verbose)
printf("client(%s): msg-count=%d\n",
my_name, msg_count);
count++;
if (cancel && (count >= count_cancel)) {
if (verbose)
printf("client(%s): cancel, count=%d\n",
my_name, count);
count_cancel = rnd(cancel);
count = 0;
tago = out_list[inxs][inxo];
if (tago == 0) {
for (inxx = maxout - 1; inxx > 0; inxx--) {
tago = out_list[inxs][inxx];
if (tago > 0)
break;
}
}
if (verbose)
printf("client(%s): cancel, tag=" PFTAG "\n",
my_name, tago);
ferr = BCANCELREQ(filenums[inxs], tago);
util_check("BCANCELREQ", ferr);
} else {
tfilenum = filenums[inxs];
bcc = BAWAITIOX(&tfilenum,
&buf,
&count_xferred,
&tago,
timeout,
NULL);
TEST_CHK_BCCEQ(bcc);
assert(tago <= maxout);
out_list[inxs][tago-1] = 0;
}
}
}
if (mq) {
if ((inxl % 100) == 0)
printf("client(%s): count=%d\n", my_name, inxl);
}
}
for (inxs = 0; inxs < maxsp; inxs++) {
ferr = BFILE_CLOSE_(filenums[inxs]);
TEST_CHK_FEOK(ferr);
}
} else {
ferr = XCONTROLMESSAGESYSTEM(XCTLMSGSYS_SETRECVLIMIT,
XMAX_SETTABLE_RECVLIMIT);
assert(ferr == XZFIL_ERR_OK);
ferr = XFILE_OPEN_((char *) "$RECEIVE", 8, &filenumr,
0, 0, 0,
1, 0, // sys msg
0, 0, NULL);
TEST_CHK_FEOK(ferr);
closes = 0;
msg_count = 0;
// process requests
for (;;) {
bcc = BREADUPDATEX(filenumr,
recv_buffer,
BUFSIZ,
&count_read,
0);
if (_xstatus_ne(bcc)) {
int mt = sys_msg->u_z_msg.z_msgnumber[0];
if (mt == XZSYS_VAL_SMSG_CLOSE) {
closes++;
if (verbose)
printf("server(%s): closes=%d\n",
my_name, closes);
} else {
const char *mtstr = msfs_util_get_sysmsg_str(mt);
if (verbose)
printf("server(%s): type=%s(%d)\n", my_name, mtstr, mt);
}
} else {
msg_count++;
if (verbose)
printf("server(%s): msg-count=%d\n",
my_name, msg_count);
}
bcc = BREPLYX(recv_buffer,
count_read,
&count_written,
0,
XZFIL_ERR_OK);
TEST_CHK_BCCEQ(bcc);
if (closes >= maxcp)
break;
}
}
ferr = file_mon_process_shutdown();
TEST_CHK_FEOK(ferr);
util_test_finish(client);
return 0;
}
int main(int argc, char *argv[]) {
int abandon = 0;
bool client = false;
int closes;
int count;
int count_abandon;
int ferr;
int inxl;
int inxo;
int inxs;
int lerr;
int loop = 10;
int maxcp = 1;
int maxout = 1;
int maxsp = 1;
int msgid[MAX_OUT];
int msg_count;
bool mq = false;
int oid;
TPT_DECL2 (phandle, MAX_SRV);
int recv_len;
RT results;
int send_len;
char serv[20];
BMS_SRE sre;
bool verbose = false;
TAD zargs[] = {
{ "-abandon", TA_Int, TA_NOMAX, &abandon },
{ "-client", TA_Bool, TA_NOMAX, &client },
{ "-loop", TA_Int, TA_NOMAX, &loop },
{ "-maxcp", TA_Int, MAX_CLI, &maxcp },
{ "-maxout", TA_Int, MAX_OUT, &maxout },
{ "-maxsp", TA_Int, MAX_SRV, &maxsp },
{ "-mq", TA_Bool, TA_NOMAX, &mq },
{ "-server", TA_Ign, TA_NOMAX, NULL },
{ "-v", TA_Bool, TA_NOMAX, &verbose },
{ "", TA_End, TA_NOMAX, NULL }
};
ferr = msg_init(&argc, &argv);
TEST_CHK_FEOK(ferr);
msfs_util_init_fs(&argc, &argv, msg_debug_hook);
arg_proc_args(zargs, false, argc, argv);
util_test_start(client);
ferr = msg_mon_process_startup(!client); // system messages?
TEST_CHK_FEOK(ferr);
ferr = msg_mon_get_my_process_name(my_name, BUFSIZ);
util_check("msg_mon_get_my_process_name", ferr);
if (client) {
ferr = XCONTROLMESSAGESYSTEM(XCTLMSGSYS_SETSENDLIMIT,
XMAX_SETTABLE_SENDLIMIT);
assert(ferr == XZFIL_ERR_OK);
msg_count = 0;
count_abandon = 0;
for (inxl = 0; inxl < loop; inxl++) {
for (inxs = 0; inxs < maxsp; inxs++) {
sprintf(serv, "$srv%d", inxs);
ferr = msg_mon_open_process((char *) serv, // name
TPT_REF2(phandle, inxs),
&oid);
TEST_CHK_FEOK(ferr);
}
count = 0;
if (abandon)
count_abandon = rnd(abandon);
for (inxs = 0; inxs < maxsp; inxs++) {
for (inxo = 0; inxo < maxout; inxo++) {
send_len = rnd(BUFSIZ);
ferr = BMSG_LINK_(TPT_REF2(phandle, inxs), // phandle
&msgid[inxo], // msgid
NULL, // reqctrl
0, // reqctrlsize
NULL, // replyctrl
0, // replyctrlmax
send_buffer[inxo], // reqdata
send_len, // reqdatasize
recv_buffer[inxo], // replydata
BUFSIZ, // replydatamax
0, // linkertag
0, // pri
0, // xmitclass
0); // linkopts
util_check("XMSG_LINK_", ferr);
}
}
for (inxs = 0; inxs < maxsp; inxs++) {
for (inxo = 0; inxo < maxout; inxo++) {
msg_count++;
if (verbose)
printf("client(%s): msg-count=%d\n",
my_name, msg_count);
count++;
if (abandon && (count >= count_abandon)) {
if (verbose)
printf("client(%s): sending abandon, count=%d\n",
my_name, count);
count_abandon = rnd(abandon);
count = 0;
ferr = XMSG_ABANDON_(msgid[inxo]);
util_check("XMSG_ABANDON_", ferr);
} else {
ferr = BMSG_BREAK_(msgid[inxo],
results.u.s,
TPT_REF2(phandle, inxs));
util_check("XMSG_BREAK_", ferr);
}
}
}
if (mq) {
if ((inxl % 100) == 0)
printf("client(%s): count=%d\n", my_name, inxl);
}
}
for (inxs = 0; inxs < maxsp; inxs++) {
ferr = msg_mon_close_process(TPT_REF2(phandle, inxs));
TEST_CHK_FEOK(ferr);
}
} else {
ferr = XCONTROLMESSAGESYSTEM(XCTLMSGSYS_SETRECVLIMIT,
XMAX_SETTABLE_RECVLIMIT);
assert(ferr == XZFIL_ERR_OK);
closes = 0;
msg_count = 0;
msg_mon_enable_mon_messages(true);
// process requests
for (;;) {
do {
lerr = XWAIT(LREQ, -1);
lerr = BMSG_LISTEN_((short *) &sre, // sre
0, // listenopts
0); // listenertag
} while (lerr == XSRETYPE_NOWORK);
if (sre.sre_flags & XSRE_MON) {
ferr = XMSG_READDATA_(sre.sre_msgId, // msgid
recv_buffer[0], // reqdata
BUFSIZ); // bytecount
util_check("XMSG_READDATA_", ferr);
MS_Mon_Msg *msg = (MS_Mon_Msg *) recv_buffer[0];
if (verbose)
printf("server(%s): mon-msg type=%d\n",
my_name, msg->type);
if (msg->type == MS_MsgType_Close) {
closes++;
if (verbose)
printf("server(%s): closes=%d\n",
my_name, closes);
}
} else {
msg_count++;
if (verbose)
printf("server(%s): msg-count=%d\n",
my_name, msg_count);
}
recv_len = rnd(BUFSIZ);
BMSG_REPLY_(sre.sre_msgId, // msgid
NULL, // replyctrl
0, // replyctrlsize
recv_buffer[0], // replydata
recv_len, // replydatasize
0, // errorclass
NULL); // newphandle
if (closes >= maxcp)
break;
}
}
ferr = msg_mon_process_shutdown();
TEST_CHK_FEOK(ferr);
util_test_finish(client);
return 0;
}
int main(int argc, char *argv[]) {
bool client = false;
int ferr;
int inxl;
int inxo;
int inxs;
int maxs = 2;
int msgid[MAX_OUT];
bool mq = false;
int oid;
TPT_DECL (phandle);
void *res;
RT results;
const char *serv = "$srv";
int status;
TAD zargs[] = {
{ "-client", TA_Bool, TA_NOMAX, &client },
{ "-loop", TA_Int, TA_NOMAX, &loop },
{ "-maxout", TA_Int, MAX_OUT, &maxout },
{ "-maxs", TA_Int, MAX_THR_S, &maxs },
{ "-mq", TA_Bool, TA_NOMAX, &mq },
{ "-server", TA_Ign, TA_NOMAX, NULL },
{ "-v", TA_Bool, TA_NOMAX, &verbose },
{ "", TA_End, TA_NOMAX, NULL }
};
ferr = msg_init(&argc, &argv);
TEST_CHK_FEOK(ferr);
msfs_util_init_fs(&argc, &argv, msg_debug_hook);
arg_proc_args(zargs, false, argc, argv);
util_test_start(client);
ferr = msg_mon_process_startup(!client); // system messages?
TEST_CHK_FEOK(ferr);
ferr = msg_mon_get_my_process_name(my_name, BUFSIZ);
util_check("msg_mon_get_my_process_name", ferr);
if (client) {
ferr = XCONTROLMESSAGESYSTEM(XCTLMSGSYS_SETSENDLIMIT,
XMAX_SETTABLE_SENDLIMIT);
assert(ferr == XZFIL_ERR_OK);
atomic_set(&msg_count, 0);
for (inxl = 0; inxl < loop; inxl++) {
ferr = msg_mon_open_process((char *) serv, // name
TPT_REF(phandle),
&oid);
TEST_CHK_FEOK(ferr);
count = 0;
for (inxo = 0; inxo < 2; inxo++) {
ferr = BMSG_LINK_(TPT_REF(phandle), // phandle
&msgid[inxo], // msgid
NULL, // reqctrl
0, // reqctrlsize
send_buffer2[inxo], // replyctrl
24, // replyctrlmax
send_buffer[inxo], // reqdata
0, // reqdatasize
recv_buffer[inxo], // replydata
BUFSIZ, // replydatamax
0, // linkertag
0, // pri
0, // xmitclass
0); // linkopts
util_check("XMSG_LINK_", ferr);
atomic_inc(&msg_count);
}
ferr = XMSG_ABANDON_(msgid[0]);
util_check("XMSG_ABANDON_", ferr);
ferr = BMSG_LINK_(TPT_REF(phandle), // phandle
&msgid[inxo], // msgid
NULL, // reqctrl
0, // reqctrlsize
send_buffer2[inxo], // replyctrl
24, // replyctrlmax
send_buffer[inxo], // reqdata
0, // reqdatasize
recv_buffer[inxo], // replydata
BUFSIZ, // replydatamax
0, // linkertag
0, // pri
0, // xmitclass
0); // linkopts
util_check("XMSG_LINK_", ferr);
atomic_inc(&msg_count);
ferr = BMSG_BREAK_(msgid[inxo],
results.u.s,
TPT_REF(phandle));
util_check("XMSG_BREAK_", ferr);
ferr = XMSG_ABANDON_(msgid[1]);
util_check("XMSG_ABANDON_", ferr);
if (maxout < 4)
maxout = 4;
for (inxo = 3; inxo < maxout; inxo++) {
ferr = BMSG_LINK_(TPT_REF(phandle), // phandle
&msgid[inxo], // msgid
NULL, // reqctrl
0, // reqctrlsize
send_buffer2[inxo], // replyctrl
60, // replyctrlmax
send_buffer[inxo], // reqdata
120, // reqdatasize
recv_buffer[inxo], // replydata
BUFSIZ, // replydatamax
0, // linkertag
0, // pri
0, // xmitclass
0); // linkopts
util_check("XMSG_LINK_", ferr);
atomic_inc(&msg_count);
if (verbose)
printf("client(%s): msg-count=%d\n",
my_name, atomic_read(&msg_count));
count++;
ferr = BMSG_BREAK_(msgid[inxo],
results.u.s,
TPT_REF(phandle));
util_check("XMSG_BREAK_", ferr);
}
if (mq) {
if ((inxl % 100) == 0)
printf("client(%s): count=%d\n", my_name, inxl);
}
}
ferr = msg_mon_close_process(TPT_REF(phandle));
TEST_CHK_FEOK(ferr);
} else {
ferr = XCONTROLMESSAGESYSTEM(XCTLMSGSYS_SETRECVLIMIT,
XMAX_SETTABLE_RECVLIMIT);
assert(ferr == XZFIL_ERR_OK);
closes = 0;
maxmsg = loop * maxout;
atomic_set(&msg_count, 0);
msg_mon_enable_mon_messages(true);
for (inxs = 0; inxs < maxs; inxs++) {
char lname[10];
sprintf(lname, "s%d", inxs);
thrs[inxs] = new MyThread(server_thr, lname, inxs);
}
for (inxs = 0; inxs < maxs; inxs++)
thrs[inxs]->start();
for (inxs = 0; inxs < maxs; inxs++) {
status = thrs[inxs]->join(&res);
TEST_CHK_STATUSOK(status);
printf("joined with server %d\n", inxs);
}
}
ferr = msg_mon_process_shutdown();
TEST_CHK_FEOK(ferr);
util_test_finish(client);
return 0;
}
