//timeout is in microseconds
void LLPumpIO::pump(const S32& poll_timeout)
{
LLMemType m1(LLMemType::MTYPE_IO_PUMP);
LLFastTimer t1(LLFastTimer::FTM_PUMP);
//llinfos << "LLPumpIO::pump()" << llendl;
// Run any pending runners.
mRunner.run();
// We need to move all of the pending heads over to the running
// chains.
PUMP_DEBUG;
if(true)
{
#if LL_THREADS_APR
LLScopedLock lock(mChainsMutex);
#endif
// bail if this pump is paused.
if(PAUSING == mState)
{
mState = PAUSED;
}
if(PAUSED == mState)
{
return;
}
PUMP_DEBUG;
// Move the pending chains over to the running chaings
if(!mPendingChains.empty())
{
PUMP_DEBUG;
//lldebugs << "Pushing " << mPendingChains.size() << "." << llendl;
std::copy(
mPendingChains.begin(),
mPendingChains.end(),
std::back_insert_iterator<running_chains_t>(mRunningChains));
mPendingChains.clear();
PUMP_DEBUG;
}
// Clear any locks. This needs to be done here so that we do
// not clash during a call to clearLock().
if(!mClearLocks.empty())
{
PUMP_DEBUG;
running_chains_t::iterator it = mRunningChains.begin();
running_chains_t::iterator end = mRunningChains.end();
std::set<S32>::iterator not_cleared = mClearLocks.end();
for(; it != end; ++it)
{
if((*it).mLock && mClearLocks.find((*it).mLock) != not_cleared)
{
(*it).mLock = 0;
}
}
PUMP_DEBUG;
mClearLocks.clear();
}
}
PUMP_DEBUG;
// rebuild the pollset if necessary
if(mRebuildPollset)
{
PUMP_DEBUG;
rebuildPollset();
mRebuildPollset = false;
}
// Poll based on the last known pollset
// *TODO: may want to pass in a poll timeout so it works correctly
// in single and multi threaded processes.
PUMP_DEBUG;
typedef std::map<S32, S32> signal_client_t;
signal_client_t signalled_client;
const apr_pollfd_t* poll_fd = NULL;
if(mPollset)
{
PUMP_DEBUG;
//llinfos << "polling" << llendl;
S32 count = 0;
S32 client_id = 0;
{
LLPerfBlock polltime("pump_poll");
apr_pollset_poll(mPollset, poll_timeout, &count, &poll_fd);
}
PUMP_DEBUG;
for(S32 ii = 0; ii < count; ++ii)
{
ll_debug_poll_fd("Signalled pipe", &poll_fd[ii]);
client_id = *((S32*)poll_fd[ii].client_data);
signalled_client[client_id] = ii;
}
PUMP_DEBUG;
}
PUMP_DEBUG;
// set up for a check to see if each one was signalled
signal_client_t::iterator not_signalled = signalled_client.end();
// Process everything as appropriate
//lldebugs << "Running chain count: " << mRunningChains.size() << llendl;
running_chains_t::iterator run_chain = mRunningChains.begin();
bool process_this_chain = false;
for(; run_chain != mRunningChains.end(); )
{
PUMP_DEBUG;
if((*run_chain).mInit
&& (*run_chain).mTimer.getStarted()
&& (*run_chain).mTimer.hasExpired())
{
PUMP_DEBUG;
if(handleChainError(*run_chain, LLIOPipe::STATUS_EXPIRED))
{
// the pipe probably handled the error. If the handler
// forgot to reset the expiration then we need to do
// that here.
if((*run_chain).mTimer.getStarted()
&& (*run_chain).mTimer.hasExpired())
{
PUMP_DEBUG;
llinfos << "Error handler forgot to reset timeout. "
<< "Resetting to " << DEFAULT_CHAIN_EXPIRY_SECS
<< " seconds." << llendl;
(*run_chain).setTimeoutSeconds(DEFAULT_CHAIN_EXPIRY_SECS);
}
}
else
{
PUMP_DEBUG;
// it timed out and no one handled it, so we need to
// retire the chain
#if LL_DEBUG_PIPE_TYPE_IN_PUMP
lldebugs << "Removing chain "
<< (*run_chain).mChainLinks[0].mPipe
<< " '"
<< typeid(*((*run_chain).mChainLinks[0].mPipe)).name()
<< "' because it timed out." << llendl;
#else
// lldebugs << "Removing chain "
// << (*run_chain).mChainLinks[0].mPipe
// << " because we reached the end." << llendl;
#endif
run_chain = mRunningChains.erase(run_chain);
continue;
}
}
PUMP_DEBUG;
if((*run_chain).mLock)
{
++run_chain;
continue;
}
PUMP_DEBUG;
mCurrentChain = run_chain;
if((*run_chain).mDescriptors.empty())
{
// if there are no conditionals, just process this chain.
process_this_chain = true;
//lldebugs << "no conditionals - processing" << llendl;
}
else
{
PUMP_DEBUG;
//lldebugs << "checking conditionals" << llendl;
// Check if this run chain was signalled. If any file
// descriptor is ready for something, then go ahead and
// process this chian.
process_this_chain = false;
if(!signalled_client.empty())
{
PUMP_DEBUG;
LLChainInfo::conditionals_t::iterator it;
it = (*run_chain).mDescriptors.begin();
LLChainInfo::conditionals_t::iterator end;
end = (*run_chain).mDescriptors.end();
S32 client_id = 0;
signal_client_t::iterator signal;
for(; it != end; ++it)
{
PUMP_DEBUG;
client_id = *((S32*)((*it).second.client_data));
signal = signalled_client.find(client_id);
if (signal == not_signalled) continue;
static const apr_int16_t POLL_CHAIN_ERROR =
APR_POLLHUP | APR_POLLNVAL | APR_POLLERR;
const apr_pollfd_t* poll = &(poll_fd[(*signal).second]);
if(poll->rtnevents & POLL_CHAIN_ERROR)
{
// Potential eror condition has been
// returned. If HUP was one of them, we pass
// that as the error even though there may be
// more. If there are in fact more errors,
// we'll just wait for that detection until
// the next pump() cycle to catch it so that
// the logic here gets no more strained than
// it already is.
LLIOPipe::EStatus error_status;
if(poll->rtnevents & APR_POLLHUP)
error_status = LLIOPipe::STATUS_LOST_CONNECTION;
else
error_status = LLIOPipe::STATUS_ERROR;
if(handleChainError(*run_chain, error_status)) break;
ll_debug_poll_fd("Removing pipe", poll);
llwarns << "Removing pipe "
<< (*run_chain).mChainLinks[0].mPipe
<< " '"
#if LL_DEBUG_PIPE_TYPE_IN_PUMP
<< typeid(
*((*run_chain).mChainLinks[0].mPipe)).name()
#endif
<< "' because: "
<< events_2_string(poll->rtnevents)
<< llendl;
(*run_chain).mHead = (*run_chain).mChainLinks.end();
break;
}
// at least 1 fd got signalled, and there were no
// errors. That means we process this chain.
process_this_chain = true;
break;
}
}
}
if(process_this_chain)
{
PUMP_DEBUG;
if(!((*run_chain).mInit))
{
(*run_chain).mHead = (*run_chain).mChainLinks.begin();
(*run_chain).mInit = true;
}
PUMP_DEBUG;
processChain(*run_chain);
}
PUMP_DEBUG;
if((*run_chain).mHead == (*run_chain).mChainLinks.end())
{
#if LL_DEBUG_PIPE_TYPE_IN_PUMP
lldebugs << "Removing chain " << (*run_chain).mChainLinks[0].mPipe
<< " '"
<< typeid(*((*run_chain).mChainLinks[0].mPipe)).name()
<< "' because we reached the end." << llendl;
#else
// lldebugs << "Removing chain " << (*run_chain).mChainLinks[0].mPipe
// << " because we reached the end." << llendl;
#endif
PUMP_DEBUG;
// This chain is done. Clean up any allocated memory and
// erase the chain info.
std::for_each(
(*run_chain).mDescriptors.begin(),
(*run_chain).mDescriptors.end(),
ll_delete_apr_pollset_fd_client_data());
run_chain = mRunningChains.erase(run_chain);
// *NOTE: may not always need to rebuild the pollset.
mRebuildPollset = true;
}
else
{
PUMP_DEBUG;
// this chain needs more processing - just go to the next
// chain.
++run_chain;
}
}
PUMP_DEBUG;
// null out the chain
mCurrentChain = mRunningChains.end();
END_PUMP_DEBUG;
}
void LLPumpIO::processChain(LLChainInfo& chain)
{
PUMP_DEBUG;
LLMemType m1(LLMemType::MTYPE_IO_PUMP);
LLIOPipe::EStatus status = LLIOPipe::STATUS_OK;
links_t::iterator it = chain.mHead;
links_t::iterator end = chain.mChainLinks.end();
bool need_process_signaled = false;
bool keep_going = true;
do
{
#if LL_DEBUG_PROCESS_LINK
#if LL_DEBUG_PIPE_TYPE_IN_PUMP
llinfos << "Processing " << typeid(*((*it).mPipe)).name() << "."
<< llendl;
#else
llinfos << "Processing link " << (*it).mPipe << "." << llendl;
#endif
#endif
#if LL_DEBUG_SPEW_BUFFER_CHANNEL_IN
if(chain.mData)
{
char* buf = NULL;
S32 bytes = chain.mData->countAfter((*it).mChannels.in(), NULL);
if(bytes)
{
buf = new char[bytes + 1];
chain.mData->readAfter(
(*it).mChannels.in(),
NULL,
(U8*)buf,
bytes);
buf[bytes] = '\0';
llinfos << "CHANNEL IN(" << (*it).mChannels.in() << "): "
<< buf << llendl;
delete[] buf;
buf = NULL;
}
else
{
llinfos << "CHANNEL IN(" << (*it).mChannels.in()<< "): (null)"
<< llendl;
}
}
#endif
PUMP_DEBUG;
status = (*it).mPipe->process(
(*it).mChannels,
chain.mData,
chain.mEOS,
chain.mContext,
this);
#if LL_DEBUG_SPEW_BUFFER_CHANNEL_OUT
if(chain.mData)
{
char* buf = NULL;
S32 bytes = chain.mData->countAfter((*it).mChannels.out(), NULL);
if(bytes)
{
buf = new char[bytes + 1];
chain.mData->readAfter(
(*it).mChannels.out(),
NULL,
(U8*)buf,
bytes);
buf[bytes] = '\0';
llinfos << "CHANNEL OUT(" << (*it).mChannels.out()<< "): "
<< buf << llendl;
delete[] buf;
buf = NULL;
}
else
{
llinfos << "CHANNEL OUT(" << (*it).mChannels.out()<< "): (null)"
<< llendl;
}
}
#endif
#if LL_DEBUG_PROCESS_RETURN_VALUE
// Only bother with the success codes - error codes are logged
// below.
if(LLIOPipe::isSuccess(status))
{
llinfos << "Pipe returned: '"
#if LL_DEBUG_PIPE_TYPE_IN_PUMP
<< typeid(*((*it).mPipe)).name() << "':'"
#endif
<< LLIOPipe::lookupStatusString(status) << "'" << llendl;
}
#endif
PUMP_DEBUG;
switch(status)
{
case LLIOPipe::STATUS_OK:
// no-op
break;
case LLIOPipe::STATUS_STOP:
PUMP_DEBUG;
status = LLIOPipe::STATUS_OK;
chain.mHead = end;
keep_going = false;
break;
case LLIOPipe::STATUS_DONE:
PUMP_DEBUG;
status = LLIOPipe::STATUS_OK;
chain.mHead = (it + 1);
chain.mEOS = true;
break;
case LLIOPipe::STATUS_BREAK:
PUMP_DEBUG;
status = LLIOPipe::STATUS_OK;
keep_going = false;
break;
case LLIOPipe::STATUS_NEED_PROCESS:
PUMP_DEBUG;
status = LLIOPipe::STATUS_OK;
if(!need_process_signaled)
{
need_process_signaled = true;
chain.mHead = it;
}
break;
default:
PUMP_DEBUG;
if(LLIOPipe::isError(status))
{
llinfos << "Pump generated pipe err: '"
#if LL_DEBUG_PIPE_TYPE_IN_PUMP
<< typeid(*((*it).mPipe)).name() << "':'"
#endif
<< LLIOPipe::lookupStatusString(status)
<< "'" << llendl;
#if LL_DEBUG_SPEW_BUFFER_CHANNEL_IN_ON_ERROR
if(chain.mData)
{
char* buf = NULL;
S32 bytes = chain.mData->countAfter(
(*it).mChannels.in(),
NULL);
if(bytes)
{
buf = new char[bytes + 1];
chain.mData->readAfter(
(*it).mChannels.in(),
NULL,
(U8*)buf,
bytes);
buf[bytes] = '\0';
llinfos << "Input After Error: " << buf << llendl;
delete[] buf;
buf = NULL;
}
else
{
llinfos << "Input After Error: (null)" << llendl;
}
}
else
{
llinfos << "Input After Error: (null)" << llendl;
}
#endif
keep_going = false;
chain.mHead = it;
if(!handleChainError(chain, status))
{
chain.mHead = end;
}
}
else
{
llinfos << "Unhandled status code: " << status << ":"
<< LLIOPipe::lookupStatusString(status) << llendl;
}
break;
}
PUMP_DEBUG;
} while(keep_going && (++it != end));
PUMP_DEBUG;
}
//timeout is in microseconds
void LLPumpIO::pump(const S32& poll_timeout)
{
LLMemType m1(LLMemType::MTYPE_IO_PUMP);
LLFastTimer t1(LLFastTimer::FTM_PUMP);
//llinfos << "LLPumpIO::pump()" << llendl;
// Run any pending runners.
mRunner.run();
// We need to move all of the pending heads over to the running
// chains.
PUMP_DEBUG;
if(true)
{
#if LL_THREADS_APR
LLScopedLock lock(mChainsMutex);
#endif
// bail if this pump is paused.
if(PAUSING == mState)
{
mState = PAUSED;
}
if(PAUSED == mState)
{
return;
}
PUMP_DEBUG;
// Move the pending chains over to the running chaings
if(!mPendingChains.empty())
{
PUMP_DEBUG;
//lldebugs << "Pushing " << mPendingChains.size() << "." << llendl;
std::copy(
mPendingChains.begin(),
mPendingChains.end(),
std::back_insert_iterator<running_chains_t>(mRunningChains));
mPendingChains.clear();
PUMP_DEBUG;
}
// Clear any locks. This needs to be done here so that we do
// not clash during a call to clearLock().
if(!mClearLocks.empty())
{
PUMP_DEBUG;
running_chains_t::iterator it = mRunningChains.begin();
running_chains_t::iterator end = mRunningChains.end();
std::set<S32>::iterator not_cleared = mClearLocks.end();
for(; it != end; ++it)
{
if((*it).mLock && mClearLocks.find((*it).mLock) != not_cleared)
{
(*it).mLock = 0;
}
}
PUMP_DEBUG;
mClearLocks.clear();
}
}
PUMP_DEBUG;
// rebuild the pollset if necessary
if(mRebuildPollset)
{
PUMP_DEBUG;
rebuildPollset();
mRebuildPollset = false;
}
// Poll based on the last known pollset
// *FIX: may want to pass in a poll timeout so it works correctly
// in single and multi threaded processes.
PUMP_DEBUG;
typedef std::set<S32> signal_client_t;
signal_client_t signalled_client;
if(mPollset)
{
PUMP_DEBUG;
//llinfos << "polling" << llendl;
S32 count = 0;
S32 client_id = 0;
const apr_pollfd_t* poll_fd = NULL;
apr_pollset_poll(mPollset, poll_timeout, &count, &poll_fd);
PUMP_DEBUG;
for(S32 i = 0; i < count; ++i)
{
client_id = *((S32*)poll_fd[i].client_data);
signalled_client.insert(client_id);
}
PUMP_DEBUG;
}
PUMP_DEBUG;
// set up for a check to see if each one was signalled
signal_client_t::iterator not_signalled = signalled_client.end();
// Process everything as appropriate
//lldebugs << "Running chain count: " << mRunningChains.size() << llendl;
running_chains_t::iterator run_chain = mRunningChains.begin();
bool process_this_chain = false;
for(; run_chain != mRunningChains.end(); )
{
PUMP_DEBUG;
if((*run_chain).mInit
&& (*run_chain).mTimer.getStarted()
&& (*run_chain).mTimer.hasExpired())
{
PUMP_DEBUG;
if(handleChainError(*run_chain, LLIOPipe::STATUS_EXPIRED))
{
// the pipe probably handled the error. If the handler
// forgot to reset the expiration then we need to do
// that here.
if((*run_chain).mTimer.getStarted()
&& (*run_chain).mTimer.hasExpired())
{
PUMP_DEBUG;
llinfos << "Error handler forgot to reset timeout. "
<< "Resetting to " << DEFAULT_CHAIN_EXPIRY_SECS
<< " seconds." << llendl;
(*run_chain).setTimeoutSeconds(DEFAULT_CHAIN_EXPIRY_SECS);
}
}
else
{
PUMP_DEBUG;
// it timed out and no one handled it, so we need to
// retire the chain
#if LL_DEBUG_PIPE_TYPE_IN_PUMP
lldebugs << "Removing chain "
<< (*run_chain).mChainLinks[0].mPipe
<< " '"
<< typeid(*((*run_chain).mChainLinks[0].mPipe)).name()
<< "' because it timed out." << llendl;
#else
// lldebugs << "Removing chain "
// << (*run_chain).mChainLinks[0].mPipe
// << " because we reached the end." << llendl;
#endif
run_chain = mRunningChains.erase(run_chain);
continue;
}
}
PUMP_DEBUG;
if((*run_chain).mLock)
{
++run_chain;
continue;
}
PUMP_DEBUG;
mCurrentChain = run_chain;
if((*run_chain).mDescriptors.empty())
{
// if there are no conditionals, just process this chain.
process_this_chain = true;
//lldebugs << "no conditionals - processing" << llendl;
}
else
{
PUMP_DEBUG;
//lldebugs << "checking conditionals" << llendl;
// Check if this run chain was signalled. If any file
// descriptor is ready for something, then go ahead and
// process this chian.
process_this_chain = false;
if(!signalled_client.empty())
{
PUMP_DEBUG;
LLChainInfo::conditionals_t::iterator it;
it = (*run_chain).mDescriptors.begin();
LLChainInfo::conditionals_t::iterator end;
end = (*run_chain).mDescriptors.end();
S32 client_id = 0;
for(; it != end; ++it)
{
PUMP_DEBUG;
client_id = *((S32*)((*it).second.client_data));
if(signalled_client.find(client_id) != not_signalled)
{
process_this_chain = true;
break;
}
//llinfos << "no fd ready for this one." << llendl;
}
}
}
if(process_this_chain)
{
PUMP_DEBUG;
if(!((*run_chain).mInit))
{
(*run_chain).mHead = (*run_chain).mChainLinks.begin();
(*run_chain).mInit = true;
}
PUMP_DEBUG;
processChain(*run_chain);
}
PUMP_DEBUG;
if((*run_chain).mHead == (*run_chain).mChainLinks.end())
{
#if LL_DEBUG_PIPE_TYPE_IN_PUMP
lldebugs << "Removing chain " << (*run_chain).mChainLinks[0].mPipe
<< " '"
<< typeid(*((*run_chain).mChainLinks[0].mPipe)).name()
<< "' because we reached the end." << llendl;
#else
// lldebugs << "Removing chain " << (*run_chain).mChainLinks[0].mPipe
// << " because we reached the end." << llendl;
#endif
PUMP_DEBUG;
// This chain is done. Clean up any allocated memory and
// erase the chain info.
std::for_each(
(*run_chain).mDescriptors.begin(),
(*run_chain).mDescriptors.end(),
ll_delete_apr_pollset_fd_client_data());
run_chain = mRunningChains.erase(run_chain);
// *NOTE: may not always need to rebuild the pollset.
mRebuildPollset = true;
}
else
{
PUMP_DEBUG;
// this chain needs more processing - just go to the next
// chain.
++run_chain;
}
}
PUMP_DEBUG;
// null out the chain
mCurrentChain = current_chain_t();
END_PUMP_DEBUG;
}