From dd1bf47394b937ae5b39485ff0138fef3c7e02c9 Mon Sep 17 00:00:00 2001 From: Robin Gareus Date: Sat, 22 Apr 2017 16:09:10 +0200 Subject: NO-OP: whitespace --- libs/ardour/graph.cc | 503 +++++++++++++++++++++++++-------------------------- 1 file changed, 251 insertions(+), 252 deletions(-) (limited to 'libs/ardour/graph.cc') diff --git a/libs/ardour/graph.cc b/libs/ardour/graph.cc index 563c882efe..f69df9beec 100644 --- a/libs/ardour/graph.cc +++ b/libs/ardour/graph.cc @@ -52,33 +52,33 @@ int alloc_allowed () #endif Graph::Graph (Session & session) - : SessionHandleRef (session) - , _threads_active (false) + : SessionHandleRef (session) + , _threads_active (false) , _execution_sem ("graph_execution", 0) , _callback_start_sem ("graph_start", 0) , _callback_done_sem ("graph_done", 0) , _cleanup_sem ("graph_cleanup", 0) { - pthread_mutex_init( &_trigger_mutex, NULL); + pthread_mutex_init( &_trigger_mutex, NULL); /* XXX: rather hacky `fix' to stop _trigger_queue.push_back() allocating - memory in the RT thread. - */ + * memory in the RT thread. + */ _trigger_queue.reserve (8192); - _execution_tokens = 0; + _execution_tokens = 0; - _current_chain = 0; - _pending_chain = 0; - _setup_chain = 1; - _graph_empty = true; + _current_chain = 0; + _pending_chain = 0; + _setup_chain = 1; + _graph_empty = true; ARDOUR::AudioEngine::instance()->Running.connect_same_thread (engine_connections, boost::bind (&Graph::reset_thread_list, this)); ARDOUR::AudioEngine::instance()->Stopped.connect_same_thread (engine_connections, boost::bind (&Graph::engine_stopped, this)); ARDOUR::AudioEngine::instance()->Halted.connect_same_thread (engine_connections, boost::bind (&Graph::engine_stopped, this)); - reset_thread_list (); + reset_thread_list (); #ifdef DEBUG_RT_ALLOC graph = this; @@ -98,67 +98,67 @@ Graph::engine_stopped () void Graph::reset_thread_list () { - uint32_t num_threads = how_many_dsp_threads (); + uint32_t num_threads = how_many_dsp_threads (); /* For now, we shouldn't be using the graph code if we only have 1 DSP thread */ assert (num_threads > 1); - /* don't bother doing anything here if we already have the right - number of threads. - */ + /* don't bother doing anything here if we already have the right + * number of threads. + */ - if (AudioEngine::instance()->process_thread_count() == num_threads) { - return; - } + if (AudioEngine::instance()->process_thread_count() == num_threads) { + return; + } - Glib::Threads::Mutex::Lock lm (_session.engine().process_lock()); + Glib::Threads::Mutex::Lock lm (_session.engine().process_lock()); - if (AudioEngine::instance()->process_thread_count() != 0) { - drop_threads (); - } + if (AudioEngine::instance()->process_thread_count() != 0) { + drop_threads (); + } - _threads_active = true; + _threads_active = true; if (AudioEngine::instance()->create_process_thread (boost::bind (&Graph::main_thread, this)) != 0) { throw failed_constructor (); } - for (uint32_t i = 1; i < num_threads; ++i) { + for (uint32_t i = 1; i < num_threads; ++i) { if (AudioEngine::instance()->create_process_thread (boost::bind (&Graph::helper_thread, this))) { throw failed_constructor (); } - } + } } void Graph::session_going_away() { - drop_threads (); - - // now drop all references on the nodes. - _nodes_rt[0].clear(); - _nodes_rt[1].clear(); - _init_trigger_list[0].clear(); - _init_trigger_list[1].clear(); - _trigger_queue.clear(); + drop_threads (); + + // now drop all references on the nodes. + _nodes_rt[0].clear(); + _nodes_rt[1].clear(); + _init_trigger_list[0].clear(); + _init_trigger_list[1].clear(); + _trigger_queue.clear(); } void Graph::drop_threads () { - Glib::Threads::Mutex::Lock ls (_swap_mutex); - _threads_active = false; + Glib::Threads::Mutex::Lock ls (_swap_mutex); + _threads_active = false; - uint32_t thread_count = AudioEngine::instance()->process_thread_count (); + uint32_t thread_count = AudioEngine::instance()->process_thread_count (); - for (unsigned int i=0; i < thread_count; i++) { + for (unsigned int i=0; i < thread_count; i++) { pthread_mutex_lock (&_trigger_mutex); _execution_sem.signal (); pthread_mutex_unlock (&_trigger_mutex); - } + } pthread_mutex_lock (&_trigger_mutex); - _callback_start_sem.signal (); + _callback_start_sem.signal (); pthread_mutex_unlock (&_trigger_mutex); AudioEngine::instance()->join_process_threads (); @@ -169,59 +169,59 @@ Graph::drop_threads () void Graph::clear_other_chain () { - Glib::Threads::Mutex::Lock ls (_swap_mutex); - - while (1) { - if (_setup_chain != _pending_chain) { - - for (node_list_t::iterator ni=_nodes_rt[_setup_chain].begin(); ni!=_nodes_rt[_setup_chain].end(); ni++) { - (*ni)->_activation_set[_setup_chain].clear(); - } - - _nodes_rt[_setup_chain].clear (); - _init_trigger_list[_setup_chain].clear (); - break; - } - /* setup chain == pending chain - we have - to wait till this is no longer true. - */ - _cleanup_cond.wait (_swap_mutex); - } + Glib::Threads::Mutex::Lock ls (_swap_mutex); + + while (1) { + if (_setup_chain != _pending_chain) { + + for (node_list_t::iterator ni=_nodes_rt[_setup_chain].begin(); ni!=_nodes_rt[_setup_chain].end(); ni++) { + (*ni)->_activation_set[_setup_chain].clear(); + } + + _nodes_rt[_setup_chain].clear (); + _init_trigger_list[_setup_chain].clear (); + break; + } + /* setup chain == pending chain - we have + * to wait till this is no longer true. + */ + _cleanup_cond.wait (_swap_mutex); + } } void Graph::prep() { - node_list_t::iterator i; - int chain; - - if (_swap_mutex.trylock()) { - // we got the swap mutex. - if (_current_chain != _pending_chain) - { - // printf ("chain swap ! %d -> %d\n", _current_chain, _pending_chain); - _setup_chain = _current_chain; - _current_chain = _pending_chain; - _cleanup_cond.signal (); - } - _swap_mutex.unlock (); - } - - chain = _current_chain; - - _graph_empty = true; - for (i=_nodes_rt[chain].begin(); i!=_nodes_rt[chain].end(); i++) { - (*i)->prep( chain); - _graph_empty = false; - } - _finished_refcount = _init_finished_refcount[chain]; + node_list_t::iterator i; + int chain; + + if (_swap_mutex.trylock()) { + // we got the swap mutex. + if (_current_chain != _pending_chain) + { + // printf ("chain swap ! %d -> %d\n", _current_chain, _pending_chain); + _setup_chain = _current_chain; + _current_chain = _pending_chain; + _cleanup_cond.signal (); + } + _swap_mutex.unlock (); + } + + chain = _current_chain; + + _graph_empty = true; + for (i=_nodes_rt[chain].begin(); i!=_nodes_rt[chain].end(); i++) { + (*i)->prep( chain); + _graph_empty = false; + } + _finished_refcount = _init_finished_refcount[chain]; /* Trigger the initial nodes for processing, which are the ones at the `input' end */ pthread_mutex_lock (&_trigger_mutex); - for (i=_init_trigger_list[chain].begin(); i!=_init_trigger_list[chain].end(); i++) { + for (i=_init_trigger_list[chain].begin(); i!=_init_trigger_list[chain].end(); i++) { /* don't use ::trigger here, as we have already locked the mutex */ - _trigger_queue.push_back (i->get ()); - } + _trigger_queue.push_back (i->get ()); + } pthread_mutex_unlock (&_trigger_mutex); } @@ -229,7 +229,7 @@ void Graph::trigger (GraphNode* n) { pthread_mutex_lock (&_trigger_mutex); - _trigger_queue.push_back (n); + _trigger_queue.push_back (n); pthread_mutex_unlock (&_trigger_mutex); } @@ -239,78 +239,77 @@ Graph::trigger (GraphNode* n) void Graph::dec_ref() { - if (g_atomic_int_dec_and_test (const_cast (&_finished_refcount))) { + if (g_atomic_int_dec_and_test (const_cast (&_finished_refcount))) { /* We have run all the nodes that are at the `output' end of - the graph, so there is nothing more to do this time around. - */ + * the graph, so there is nothing more to do this time around. + */ restart_cycle (); - } + } } void Graph::restart_cycle() { - // we are through. wakeup our caller. + // we are through. wakeup our caller. - again: - _callback_done_sem.signal (); +again: + _callback_done_sem.signal (); - /* Block until the a process callback triggers us */ - _callback_start_sem.wait(); + /* Block until the a process callback triggers us */ + _callback_start_sem.wait(); - if (!_threads_active) { - return; - } + if (!_threads_active) { + return; + } prep (); - if (_graph_empty && _threads_active) { - goto again; - } + if (_graph_empty && _threads_active) { + goto again; + } - // returning will restart the cycle. - // starting with waking up the others. + // returning will restart the cycle. + // starting with waking up the others. } /** Rechain our stuff using a list of routes (which can be in any order) and * a directed graph of their interconnections, which is guaranteed to be * acyclic. */ - void Graph::rechain (boost::shared_ptr routelist, GraphEdges const & edges) { - Glib::Threads::Mutex::Lock ls (_swap_mutex); + Glib::Threads::Mutex::Lock ls (_swap_mutex); - int chain = _setup_chain; - DEBUG_TRACE (DEBUG::Graph, string_compose ("============== setup %1\n", chain)); + int chain = _setup_chain; + DEBUG_TRACE (DEBUG::Graph, string_compose ("============== setup %1\n", chain)); /* This will become the number of nodes that do not feed any other node; - once we have processed this number of those nodes, we have finished. - */ - _init_finished_refcount[chain] = 0; + * once we have processed this number of those nodes, we have finished. + */ + _init_finished_refcount[chain] = 0; /* This will become a list of nodes that are not fed by another node, ie - those at the `input' end. - */ - _init_trigger_list[chain].clear(); + * those at the `input' end. + */ + _init_trigger_list[chain].clear(); - _nodes_rt[chain].clear(); + _nodes_rt[chain].clear(); /* Clear things out, and make _nodes_rt[chain] a copy of routelist */ - for (RouteList::iterator ri=routelist->begin(); ri!=routelist->end(); ri++) { - (*ri)->_init_refcount[chain] = 0; - (*ri)->_activation_set[chain].clear(); - _nodes_rt[chain].push_back (*ri); - } + for (RouteList::iterator ri=routelist->begin(); ri!=routelist->end(); ri++) { + (*ri)->_init_refcount[chain] = 0; + (*ri)->_activation_set[chain].clear(); + _nodes_rt[chain].push_back (*ri); + } - // now add refs for the connections. + // now add refs for the connections. - for (node_list_t::iterator ni = _nodes_rt[chain].begin(); ni != _nodes_rt[chain].end(); ni++) { + for (node_list_t::iterator ni = _nodes_rt[chain].begin(); ni != _nodes_rt[chain].end(); ni++) { - boost::shared_ptr r = boost::dynamic_pointer_cast (*ni); + boost::shared_ptr r = boost::dynamic_pointer_cast (*ni); /* The routes that are directly fed by r */ set fed_from_r = edges.from (r); @@ -327,25 +326,25 @@ Graph::rechain (boost::shared_ptr routelist, GraphEdges const & edges bool const has_input = !edges.has_none_to (r); /* Increment the refcount of any route that we directly feed */ - for (node_set_t::iterator ai = r->_activation_set[chain].begin(); ai != r->_activation_set[chain].end(); ai++) { - (*ai)->_init_refcount[chain] += 1; - } + for (node_set_t::iterator ai = r->_activation_set[chain].begin(); ai != r->_activation_set[chain].end(); ai++) { + (*ai)->_init_refcount[chain] += 1; + } - if (!has_input) { + if (!has_input) { /* no input, so this node needs to be triggered initially to get things going */ - _init_trigger_list[chain].push_back (*ni); + _init_trigger_list[chain].push_back (*ni); } - if (!has_output) { + if (!has_output) { /* no output, so this is one of the nodes that we can count off to decide - if we've finished - */ - _init_finished_refcount[chain] += 1; + * if we've finished + */ + _init_finished_refcount[chain] += 1; } - } + } - _pending_chain = chain; - dump(chain); + _pending_chain = chain; + dump(chain); } /** Called by both the main thread and all helpers. @@ -354,15 +353,15 @@ Graph::rechain (boost::shared_ptr routelist, GraphEdges const & edges bool Graph::run_one() { - GraphNode* to_run; + GraphNode* to_run; - pthread_mutex_lock (&_trigger_mutex); - if (_trigger_queue.size()) { - to_run = _trigger_queue.back(); - _trigger_queue.pop_back(); - } else { - to_run = 0; - } + pthread_mutex_lock (&_trigger_mutex); + if (_trigger_queue.size()) { + to_run = _trigger_queue.back(); + _trigger_queue.pop_back(); + } else { + to_run = 0; + } /* the number of threads that are asleep */ int et = _execution_tokens; @@ -370,39 +369,39 @@ Graph::run_one() int ts = _trigger_queue.size(); /* hence how many threads to wake up */ - int wakeup = min (et, ts); + int wakeup = min (et, ts); /* update the number of threads that will still be sleeping */ - _execution_tokens -= wakeup; - - DEBUG_TRACE(DEBUG::ProcessThreads, string_compose ("%1 signals %2\n", pthread_name(), wakeup)); - - for (int i = 0; i < wakeup; i++) { - _execution_sem.signal (); - } - - while (to_run == 0) { - _execution_tokens += 1; - pthread_mutex_unlock (&_trigger_mutex); - DEBUG_TRACE (DEBUG::ProcessThreads, string_compose ("%1 goes to sleep\n", pthread_name())); - _execution_sem.wait (); - if (!_threads_active) { - return true; - } - DEBUG_TRACE (DEBUG::ProcessThreads, string_compose ("%1 is awake\n", pthread_name())); - pthread_mutex_lock (&_trigger_mutex); - if (_trigger_queue.size()) { - to_run = _trigger_queue.back(); - _trigger_queue.pop_back(); - } - } - pthread_mutex_unlock (&_trigger_mutex); - - to_run->process(); - to_run->finish (_current_chain); - - DEBUG_TRACE(DEBUG::ProcessThreads, string_compose ("%1 has finished run_one()\n", pthread_name())); - - return !_threads_active; + _execution_tokens -= wakeup; + + DEBUG_TRACE(DEBUG::ProcessThreads, string_compose ("%1 signals %2\n", pthread_name(), wakeup)); + + for (int i = 0; i < wakeup; i++) { + _execution_sem.signal (); + } + + while (to_run == 0) { + _execution_tokens += 1; + pthread_mutex_unlock (&_trigger_mutex); + DEBUG_TRACE (DEBUG::ProcessThreads, string_compose ("%1 goes to sleep\n", pthread_name())); + _execution_sem.wait (); + if (!_threads_active) { + return true; + } + DEBUG_TRACE (DEBUG::ProcessThreads, string_compose ("%1 is awake\n", pthread_name())); + pthread_mutex_lock (&_trigger_mutex); + if (_trigger_queue.size()) { + to_run = _trigger_queue.back(); + _trigger_queue.pop_back(); + } + } + pthread_mutex_unlock (&_trigger_mutex); + + to_run->process(); + to_run->finish (_current_chain); + + DEBUG_TRACE(DEBUG::ProcessThreads, string_compose ("%1 has finished run_one()\n", pthread_name())); + + return !_threads_active; } void @@ -467,26 +466,26 @@ void Graph::dump (int chain) { #ifndef NDEBUG - node_list_t::iterator ni; - node_set_t::iterator ai; - - chain = _pending_chain; - - DEBUG_TRACE (DEBUG::Graph, "--------------------------------------------Graph dump:\n"); - for (ni=_nodes_rt[chain].begin(); ni!=_nodes_rt[chain].end(); ni++) { - boost::shared_ptr rp = boost::dynamic_pointer_cast( *ni); - DEBUG_TRACE (DEBUG::Graph, string_compose ("GraphNode: %1 refcount: %2\n", rp->name().c_str(), (*ni)->_init_refcount[chain])); - for (ai=(*ni)->_activation_set[chain].begin(); ai!=(*ni)->_activation_set[chain].end(); ai++) { - DEBUG_TRACE (DEBUG::Graph, string_compose (" triggers: %1\n", boost::dynamic_pointer_cast(*ai)->name().c_str())); - } - } - - DEBUG_TRACE (DEBUG::Graph, "------------- trigger list:\n"); - for (ni=_init_trigger_list[chain].begin(); ni!=_init_trigger_list[chain].end(); ni++) { - DEBUG_TRACE (DEBUG::Graph, string_compose ("GraphNode: %1 refcount: %2\n", boost::dynamic_pointer_cast(*ni)->name().c_str(), (*ni)->_init_refcount[chain])); - } - - DEBUG_TRACE (DEBUG::Graph, string_compose ("final activation refcount: %1\n", _init_finished_refcount[chain])); + node_list_t::iterator ni; + node_set_t::iterator ai; + + chain = _pending_chain; + + DEBUG_TRACE (DEBUG::Graph, "--------------------------------------------Graph dump:\n"); + for (ni=_nodes_rt[chain].begin(); ni!=_nodes_rt[chain].end(); ni++) { + boost::shared_ptr rp = boost::dynamic_pointer_cast( *ni); + DEBUG_TRACE (DEBUG::Graph, string_compose ("GraphNode: %1 refcount: %2\n", rp->name().c_str(), (*ni)->_init_refcount[chain])); + for (ai=(*ni)->_activation_set[chain].begin(); ai!=(*ni)->_activation_set[chain].end(); ai++) { + DEBUG_TRACE (DEBUG::Graph, string_compose (" triggers: %1\n", boost::dynamic_pointer_cast(*ai)->name().c_str())); + } + } + + DEBUG_TRACE (DEBUG::Graph, "------------- trigger list:\n"); + for (ni=_init_trigger_list[chain].begin(); ni!=_init_trigger_list[chain].end(); ni++) { + DEBUG_TRACE (DEBUG::Graph, string_compose ("GraphNode: %1 refcount: %2\n", boost::dynamic_pointer_cast(*ni)->name().c_str(), (*ni)->_init_refcount[chain])); + } + + DEBUG_TRACE (DEBUG::Graph, string_compose ("final activation refcount: %1\n", _init_finished_refcount[chain])); #endif } @@ -495,24 +494,24 @@ Graph::silent_process_routes (pframes_t nframes, framepos_t start_frame, framepo { if (!_threads_active) return 0; - _process_nframes = nframes; - _process_start_frame = start_frame; - _process_end_frame = end_frame; + _process_nframes = nframes; + _process_start_frame = start_frame; + _process_end_frame = end_frame; - _process_silent = true; - _process_noroll = false; - _process_retval = 0; - _process_need_butler = false; + _process_silent = true; + _process_noroll = false; + _process_retval = 0; + _process_need_butler = false; - if (!_graph_empty) { + if (!_graph_empty) { DEBUG_TRACE(DEBUG::ProcessThreads, "wake graph for silent process\n"); - _callback_start_sem.signal (); - _callback_done_sem.wait (); - } + _callback_start_sem.signal (); + _callback_done_sem.wait (); + } - need_butler = _process_need_butler; + need_butler = _process_need_butler; - return _process_retval; + return _process_retval; } int @@ -522,25 +521,25 @@ Graph::process_routes (pframes_t nframes, framepos_t start_frame, framepos_t end if (!_threads_active) return 0; - _process_nframes = nframes; - _process_start_frame = start_frame; - _process_end_frame = end_frame; - _process_declick = declick; + _process_nframes = nframes; + _process_start_frame = start_frame; + _process_end_frame = end_frame; + _process_declick = declick; - _process_silent = false; - _process_noroll = false; - _process_retval = 0; - _process_need_butler = false; + _process_silent = false; + _process_noroll = false; + _process_retval = 0; + _process_need_butler = false; DEBUG_TRACE(DEBUG::ProcessThreads, "wake graph for non-silent process\n"); - _callback_start_sem.signal (); + _callback_start_sem.signal (); _callback_done_sem.wait (); DEBUG_TRACE (DEBUG::ProcessThreads, "graph execution complete\n"); - need_butler = _process_need_butler; + need_butler = _process_need_butler; - return _process_retval; + return _process_retval; } int @@ -551,50 +550,50 @@ Graph::routes_no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end if (!_threads_active) return 0; - _process_nframes = nframes; - _process_start_frame = start_frame; - _process_end_frame = end_frame; - _process_declick = declick; - _process_non_rt_pending = non_rt_pending; + _process_nframes = nframes; + _process_start_frame = start_frame; + _process_end_frame = end_frame; + _process_declick = declick; + _process_non_rt_pending = non_rt_pending; - _process_silent = false; - _process_noroll = true; - _process_retval = 0; - _process_need_butler = false; + _process_silent = false; + _process_noroll = true; + _process_retval = 0; + _process_need_butler = false; DEBUG_TRACE(DEBUG::ProcessThreads, "wake graph for no-roll process\n"); - _callback_start_sem.signal (); - _callback_done_sem.wait (); + _callback_start_sem.signal (); + _callback_done_sem.wait (); - return _process_retval; + return _process_retval; } void Graph::process_one_route (Route* route) { - bool need_butler = false; - int retval; - - assert (route); - - DEBUG_TRACE (DEBUG::ProcessThreads, string_compose ("%1 runs route %2\n", pthread_name(), route->name())); - - if (_process_silent) { - retval = route->silent_roll (_process_nframes, _process_start_frame, _process_end_frame, need_butler); - } else if (_process_noroll) { - route->set_pending_declick (_process_declick); - retval = route->no_roll (_process_nframes, _process_start_frame, _process_end_frame, _process_non_rt_pending); - } else { - route->set_pending_declick (_process_declick); - retval = route->roll (_process_nframes, _process_start_frame, _process_end_frame, _process_declick, need_butler); - } - - if (retval) { - _process_retval = retval; - } - - if (need_butler) { - _process_need_butler = true; - } + bool need_butler = false; + int retval; + + assert (route); + + DEBUG_TRACE (DEBUG::ProcessThreads, string_compose ("%1 runs route %2\n", pthread_name(), route->name())); + + if (_process_silent) { + retval = route->silent_roll (_process_nframes, _process_start_frame, _process_end_frame, need_butler); + } else if (_process_noroll) { + route->set_pending_declick (_process_declick); + retval = route->no_roll (_process_nframes, _process_start_frame, _process_end_frame, _process_non_rt_pending); + } else { + route->set_pending_declick (_process_declick); + retval = route->roll (_process_nframes, _process_start_frame, _process_end_frame, _process_declick, need_butler); + } + + if (retval) { + _process_retval = retval; + } + + if (need_butler) { + _process_need_butler = true; + } } bool -- cgit v1.2.3