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