void QueueManager::sortQueue(QueueType queue) { lockQueue(queue); _queue[queue].sort(queueComp); unlockQueue(queue); }
bool RunPotentialParamsQueue::getWork() { if(!fs::exists(mySettings.queueFile)) return false; ip::file_lock lock(mySettings.queueFile.string().c_str()); ip::scoped_lock< ip::file_lock> lockQueue(lock); fs::fstream queueStream(mySettings.queueFile); std::stringstream takenWorkItems, originalContents; std::string line; size_t numParamsRead = 0; while(numParamsRead < myNumWorkItemsChunk) { if(!std::getline(queueStream, line)) break; bool takenWork = false; if(!line.empty() && line[0] != '#') { const boost::optional< Params> & params = readParams(line); if(params) { ++numParamsRead; myParamsQueue.push(*params); takenWorkItems << "#" << spl::os::getProcessId() << " " << line << "\n"; takenWork = true; } } if(!takenWork) originalContents << line << "\n"; } if(numParamsRead > 0) { // Save the rest of the file to buffer std::copy(std::istreambuf_iterator< char>(queueStream), std::istreambuf_iterator< char>(), std::ostreambuf_iterator< char>(originalContents)); // Go back to the start of the file queueStream.clear(); // Clear the EoF flag queueStream.seekg(0, std::ios::beg); // Write out the whole new contents // First the rest of the file std::copy(std::istreambuf_iterator< char>(originalContents), std::istreambuf_iterator< char>(), std::ostreambuf_iterator< char>(queueStream)); // Then the part of the queue that we're running std::copy(std::istreambuf_iterator< char>(takenWorkItems), std::istreambuf_iterator< char>(), std::ostreambuf_iterator< char>(queueStream)); } queueStream.close(); return numParamsRead > 0; }
void CommandQueue::waitCycle() { if (lockQueue()) { executeCommands(); unlockQueue(); } }
void Renderable::show() { lockQueue(_queueVisible); addToQueue(_queueVisible); sortQueue(_queueVisible); unlockQueue(_queueVisible); }
void submitJob( IJob* job ) { m_jobQueue.push_back( job ); lockQueue(); m_tailIndex++; m_queueIsEmpty = false; unlockQueue(); }
void QueueManager::removeFromQueue(QueueType queue, const std::list<Queueable *>::iterator &ref) { lockQueue(queue); _queue[queue].erase(ref); unlockQueue(queue); }
void clearQueue() { lockQueue(); m_headIndex = 0; m_tailIndex = 0; m_queueIsEmpty = true; unlockQueue(); m_jobQueue.resizeNoInitialize( 0 ); }
std::list<Queueable *>::iterator QueueManager::addToQueue(QueueType queue, Queueable &q) { lockQueue(queue); _queue[queue].push_back(&q); std::list<Queueable *>::iterator ref = --_queue[queue].end(); unlockQueue(queue); return ref; }
void QueueManager::clearQueue(QueueType queue) { lockQueue(queue); for (std::list<Queueable *>::iterator q = _queue[queue].begin(); q != _queue[queue].end(); ++q) (*q)->kickedOut(queue); _queue[queue].clear(); unlockQueue(queue); }
// sets the maximum log lines captured for the final // display to the user on failure exit void log_captureLines (int num) { if (num > MAX_LOG_ENTRIES) num = MAX_LOG_ENTRIES; if (num < 1) num = 1; maxDisp = num; // remove any extra lines already on queue lockQueue (); removeExcess (0); unlockQueue (); }
static int acquireSlot (void) { int slot; lockQueue (); removeExcess (1); slot = qhead; qhead = (qhead + 1) % MAX_LOG_ENTRIES; ++qtotal; unlockQueue (); return slot; }
/** * Traitement du module */ void GameEngine::frame() { log("Debut de la gestion du jeu"); loadGameConfig(); while(core->getIsRunning()) { // Attend que la file de message ne soit plus vide boost::mutex::scoped_lock lockQueue(mutexQueue); while(message_queue.empty()) condQueue.wait(lockQueue); lockQueue.unlock(); // Traitement des messages processQueue(); } log("Fin de la gestion du jeu"); }
/** * Traitement du module d'evenements */ void EventsEngine::frame() { log("Debut de la gestion des evenements"); while(core->getIsRunning()) { // Attend que la file d'event ou de message ne soit plus vide boost::mutex::scoped_lock lockQueue(mutexQueue); while(event_queue.empty() && message_queue.empty()) condQueue.wait(lockQueue); lockQueue.unlock(); // Traitement des messages processQueue(); // Traitement des events processEventQueue(); } }
void RunPotentialParamsQueue::updateDoneParams() { if(!fs::exists(mySettings.doneFile)) return; // Update the file of finish parameters ip::file_lock lock(mySettings.doneFile.string().c_str()); ip::scoped_lock< ip::file_lock> lockQueue(lock); fs::ofstream doneStream(mySettings.doneFile, std::ios::out | std::ios::app); std::for_each(myDoneParams.begin(), myDoneParams.end(), boost::bind(&RunPotentialParamsQueue::writeParams, this, _1, boost::ref(doneStream))); doneStream.close(); myDoneParams.clear(); }
IJob* consumeJob() { if ( m_queueIsEmpty ) { // lock free path. even if this is taken erroneously it isn't harmful return NULL; } IJob* job = NULL; lockQueue(); if ( !m_queueIsEmpty ) { job = m_jobQueue[ m_headIndex++ ]; if ( m_headIndex == m_tailIndex ) { m_queueIsEmpty = true; } } unlockQueue(); return job; }