inline std::pair<T, bool> dequeue_and_begin_critical_section_on_success() { m_mutex.lock(); T elem = T(); bool success = false; // Wait while the queue is empty and this queue is alive while(m_queue.empty() && m_alive) { sleeping++; m_conditional.wait(m_mutex); sleeping--; } // An element has been added or a signal was raised if(!m_queue.empty()) { success = true; elem = m_queue.front(); m_queue.pop_front(); if (m_queue.empty() && sleeping_on_empty) { m_empty_conditional.signal(); } } if (!success) m_mutex.unlock(); return std::make_pair(elem, success); }
static inline void finish (bool output_fired, bd_t bda, bd_t bdb) { if (action_.automaton.get () != 0) { // We were executing an action of this automaton. switch (action_.action->type) { case INPUT: // We were executing an input. Move to the next input. ++input_action_pos_; proceed_to_input (); // -EEE input_action_list_.front ()->output_action.automaton->unlock_execution (); finish_output (); break; case OUTPUT: // We were executing an output ... if (output_fired) { // ... and the output output did something. output_buffer_a_ = action_.automaton->lookup_buffer (bda); // Synchronize the buffers. if (output_buffer_a_.get () != 0) { output_buffer_a_->sync (0, output_buffer_a_->size ()); } output_buffer_b_ = action_.automaton->lookup_buffer (bdb); if (output_buffer_b_.get () != 0) { output_buffer_b_->sync (0, output_buffer_b_->size ()); } // Proceed to execute the inputs. input_action_pos_ = input_action_list_.begin (); // This does not return if there are inputs. proceed_to_input (); } // No input actions to execute. // -EEE action_.automaton->unlock_execution (); finish_output (); break; case INTERNAL: case SYSTEM: // -EEE action_.automaton->unlock_execution (); break; } } // We are done with the current action. action_.automaton = shared_ptr<automaton> (); for (;;) { irq_handler::process_interrupts (); while (!ready_queue_.empty ()) { // Get the automaton context and remove it from the ready queue. automaton_context* c = ready_queue_.front (); ready_queue_.pop_front (); // Load the action. action_ = c->front (); c->pop_front (); // The automaton exists. Continue loading and execute. switch (action_.action->type) { case INPUT: // Error. Not a local action. kpanic ("Non-local action on execution queue"); break; case OUTPUT: { kassert (input_action_list_.empty ()); // Copy the bindings. action_.automaton->copy_bound_inputs (action_, back_inserter (input_action_list_)); // Sort the bindings by input automaton. sort (input_action_list_.begin (), input_action_list_.end (), sort_bindings_by_input ()); // We lock the automata in order. This is called Havender's Principle. bool output_locked = false; for (input_action_list_type::const_iterator pos = input_action_list_.begin (); pos != input_action_list_.end (); ++pos) { shared_ptr<automaton> input_automaton = (*pos)->input_action.automaton; if (!output_locked && action_.automaton->aid () < input_automaton->aid ()) { // +EEE action_.automaton->lock_execution (); output_locked = true; } // +FFF input_automaton->lock_execution (); } if (!output_locked) { // +EEE action_.automaton->lock_execution (); output_locked = true; } input_action_pos_ = input_action_list_.begin (); } break; case INTERNAL: case SYSTEM: // +EEE action_.automaton->lock_execution (); break; } if (!c->empty ()) { // Automaton has more actions, return to ready queue. ready_queue_.push_back (c); } action_.automaton->execute (*action_.action, action_.parameter, output_buffer_a_, output_buffer_b_); } // Out of actions. action_.automaton = shared_ptr<automaton> (); irq_handler::wait_for_interrupt (); } }