RSSL_THREAD_DECLARE(runChannelConnectionHandler, pArg)
{
ProviderThread *pProvThread = (ProviderThread*)pArg;
TimeValue nextTickTime;
RsslInt32 currentTicks = 0;
if (pProvThread->cpuId >= 0)
{
if (bindThread(pProvThread->cpuId) != RSSL_RET_SUCCESS)
{
printf("Error: Failed to bind thread to core %d.\n", pProvThread->cpuId);
exit(-1);
}
}
nextTickTime = getTimeNano() + nsecPerTick;
/* this is the main loop */
while(rtrLikely(!signal_shutdown))
{
for (currentTicks = 0; currentTicks < providerThreadConfig.ticksPerSec; ++currentTicks)
{
providerThreadRead(pProvThread, nextTickTime);
nextTickTime += nsecPerTick;
providerThreadSendMsgBurst(pProvThread, nextTickTime);
providerThreadReceiveNewChannels(pProvThread);
}
providerThreadCheckPings(pProvThread);
}
return RSSL_THREAD_RETURN();
}
RSSL_THREAD_DECLARE(runReactorConnectionHandler, pArg)
{
ProviderThread *pProvThread = (ProviderThread*)pArg;
TimeValue nextTickTime;
RsslInt32 currentTicks = 0;
TimeValue currentTime;
RsslRet ret;
int selRet;
struct timeval time_interval;
fd_set useRead;
fd_set useExcept;
fd_set useWrt;
RsslErrorInfo rsslErrorInfo;
RsslReactorDispatchOptions dispatchOptions;
RsslCreateReactorOptions reactorOpts;
rsslClearReactorDispatchOptions(&dispatchOptions);
if (pProvThread->cpuId >= 0)
{
if (bindThread(pProvThread->cpuId) != RSSL_RET_SUCCESS)
{
printf("Error: Failed to bind thread to core %d.\n", pProvThread->cpuId);
exit(-1);
}
}
// create reactor
rsslClearCreateReactorOptions(&reactorOpts);
if (!(pProvThread->pReactor = rsslCreateReactor(&reactorOpts, &rsslErrorInfo)))
{
printf("Reactor creation failed: %s\n", rsslErrorInfo.rsslError.text);
cleanUpAndExit();
}
FD_ZERO(&pProvThread->readfds);
FD_ZERO(&pProvThread->wrtfds);
FD_ZERO(&pProvThread->exceptfds);
/* Set the reactor's event file descriptor on our descriptor set. This, along with the file descriptors
* of RsslReactorChannels, will notify us when we should call rsslReactorDispatch(). */
FD_SET(pProvThread->pReactor->eventFd, &pProvThread->readfds);
nextTickTime = getTimeNano() + nsecPerTick;
/* this is the main loop */
while(rtrLikely(!signal_shutdown))
{
/* Loop on select(), looking for channels with available data, until stopTimeNsec is reached. */
do
{
#ifdef WIN32
/* Windows does not allow select() to be called with empty file descriptor sets. */
if (pProvThread->readfds.fd_count == 0)
{
currentTime = getTimeNano();
selRet = 0;
Sleep((DWORD)((currentTime < nextTickTime) ? (nextTickTime - currentTime)/1000000 : 0));
}
else
#endif
{
useRead = pProvThread->readfds;
useWrt = pProvThread->wrtfds;
useExcept = pProvThread->exceptfds;
currentTime = getTimeNano();
time_interval.tv_usec = (long)((currentTime < nextTickTime) ? (nextTickTime - currentTime)/1000 : 0);
time_interval.tv_sec = 0;
selRet = select(FD_SETSIZE, &useRead, &useWrt, &useExcept, &time_interval);
}
if (selRet == 0)
{
break;
}
else if (selRet > 0)
{
while ((ret = rsslReactorDispatch(pProvThread->pReactor, &dispatchOptions, &rsslErrorInfo)) > RSSL_RET_SUCCESS) {}
if (ret < RSSL_RET_SUCCESS)
{
printf("rsslReactorDispatch failed with return code: %d error = %s\n", ret, rsslErrorInfo.rsslError.text);
exit(-1);
}
}
#ifdef WIN32
else if (WSAGetLastError() != WSAEINTR)
#else
else if (errno != EINTR)
#endif
{
perror("select");
exit(-1);
}
} while (currentTime < nextTickTime);
nextTickTime += nsecPerTick;
providerThreadSendMsgBurst(pProvThread, nextTickTime);
}
return RSSL_THREAD_RETURN();
}
RSSL_THREAD_DECLARE(runNIProvConnection, pArg)
{
ProviderThread *pProviderThread = (ProviderThread*)pArg;
RsslError error;
TimeValue nextTickTime;
RsslInt32 currentTicks = 0;
RsslConnectOptions copts;
if (pProviderThread->cpuId >= 0)
{
if (bindThread(pProviderThread->cpuId) != RSSL_RET_SUCCESS)
{
printf("Error: Failed to bind thread to core %d.\n", pProviderThread->cpuId);
exit(-1);
}
}
/* Configure connection options. */
rsslClearConnectOpts(&copts);
copts.guaranteedOutputBuffers = niProvPerfConfig.guaranteedOutputBuffers;
copts.majorVersion = RSSL_RWF_MAJOR_VERSION;
copts.minorVersion = RSSL_RWF_MINOR_VERSION;
copts.protocolType = RSSL_RWF_PROTOCOL_TYPE;
copts.sysSendBufSize = niProvPerfConfig.sendBufSize;
copts.sysRecvBufSize = niProvPerfConfig.recvBufSize;
if (niProvPerfConfig.sAddr || niProvPerfConfig.rAddr)
{
if (niProvPerfConfig.connectionType != RSSL_CONN_TYPE_RELIABLE_MCAST)
{
printf("Error: Attempting non-multicast segmented connection.\n");
exit(-1);
}
copts.connectionInfo.segmented.recvAddress = niProvPerfConfig.recvAddr;
copts.connectionInfo.segmented.recvServiceName = niProvPerfConfig.recvPort;
copts.connectionInfo.segmented.sendAddress = niProvPerfConfig.sendAddr;
copts.connectionInfo.segmented.sendServiceName = niProvPerfConfig.sendPort;
copts.connectionInfo.segmented.interfaceName = niProvPerfConfig.interfaceName;
copts.connectionInfo.unified.unicastServiceName = niProvPerfConfig.unicastPort;
copts.connectionType = RSSL_CONN_TYPE_RELIABLE_MCAST;
}
else
{
copts.connectionInfo.unified.address = niProvPerfConfig.hostName;
copts.connectionInfo.unified.serviceName = niProvPerfConfig.portNo;
copts.connectionInfo.unified.interfaceName = niProvPerfConfig.interfaceName;
copts.tcp_nodelay = niProvPerfConfig.tcpNoDelay;
copts.connectionType = RSSL_CONN_TYPE_SOCKET;
}
/* Setup connection. */
do
{
ProviderSession *pProvSession;
RsslChannel *pChannel;
RsslRet ret;
if (niProvPerfConfig.sAddr || niProvPerfConfig.rAddr)
printf("\nAttempting segmented connect to server %s:%s %s:%s unicastPort %s...\n",
niProvPerfConfig.sendAddr, niProvPerfConfig.sendPort, niProvPerfConfig.recvAddr, niProvPerfConfig.recvPort, niProvPerfConfig.unicastPort);
else
printf("\nAttempting unified connect to server %s:%s...\n",
niProvPerfConfig.hostName, niProvPerfConfig.portNo) ;
if (!(pChannel = rsslConnect(&copts, &error)))
{
printf("rsslConnect() failed: %s(%s)\n", rsslRetCodeToString(error.rsslErrorId),
error.text);
SLEEP(1);
continue;
}
if (!(pProvSession = providerSessionCreate(pProviderThread, pChannel)))
{
printf("providerSessionInit() failed\n");
exit(-1);
}
do
{
ret = channelHandlerWaitForChannelInit(&pProviderThread->channelHandler,
pProvSession->pChannelInfo, 100000);
} while (!signal_shutdown && ret == RSSL_RET_CHAN_INIT_IN_PROGRESS);
if (ret < RSSL_RET_SUCCESS)
{
SLEEP(1);
continue;
}
else
break; /* Successful initialization. */
} while (!signal_shutdown);
nextTickTime = getTimeNano() + nsecPerTick;
/* this is the main loop */
while(rtrLikely(!signal_shutdown))
{
for (currentTicks = 0; currentTicks < providerThreadConfig.ticksPerSec; ++currentTicks)
{
providerThreadRead(pProviderThread, nextTickTime);
nextTickTime += nsecPerTick;
providerThreadSendMsgBurst(pProviderThread, nextTickTime);
}
providerThreadCheckPings(pProviderThread);
}
return RSSL_THREAD_RETURN();
}
