X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Flib%2Fjob_manager.cc;h=535830c0c43cc77cb42263f8af9f3e8164484251;hb=5302f2cda0afd16d714ab898549c7cd278196473;hp=3748fa3537b7e972fb5f31b5a65ca026466e78a3;hpb=d2bd0c628fd0616fe3b7dd02bd955b2c07ab48d5;p=dcpomatic.git diff --git a/src/lib/job_manager.cc b/src/lib/job_manager.cc index 3748fa353..535830c0c 100644 --- a/src/lib/job_manager.cc +++ b/src/lib/job_manager.cc @@ -1,19 +1,20 @@ /* - Copyright (C) 2012-2015 Carl Hetherington + Copyright (C) 2012-2018 Carl Hetherington - This program is free software; you can redistribute it and/or modify + This file is part of DCP-o-matic. + + DCP-o-matic is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. - This program is distributed in the hope that it will be useful, + DCP-o-matic is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + along with DCP-o-matic. If not, see . */ @@ -43,6 +44,7 @@ JobManager* JobManager::_instance = 0; JobManager::JobManager () : _terminate (false) + , _paused (false) , _scheduler (0) { @@ -52,6 +54,9 @@ void JobManager::start () { _scheduler = new boost::thread (boost::bind (&JobManager::scheduler, this)); +#ifdef DCPOMATIC_LINUX + pthread_setname_np (_scheduler->native_handle(), "job-scheduler"); +#endif } JobManager::~JobManager () @@ -62,7 +67,12 @@ JobManager::~JobManager () } if (_scheduler) { - _scheduler->join (); + /* Ideally this would be a DCPOMATIC_ASSERT(_scheduler->joinable()) but we + can't throw exceptions from a destructor. + */ + if (_scheduler->joinable ()) { + _scheduler->join (); + } } delete _scheduler; @@ -81,6 +91,21 @@ JobManager::add (shared_ptr j) return j; } +shared_ptr +JobManager::add_after (shared_ptr after, shared_ptr j) +{ + { + boost::mutex::scoped_lock lm (_mutex); + list >::iterator i = find (_jobs.begin(), _jobs.end(), after); + DCPOMATIC_ASSERT (i != _jobs.end()); + _jobs.insert (i, j); + } + + emit (boost::bind (boost::ref (JobAdded), weak_ptr (j))); + + return j; +} + list > JobManager::get () const { @@ -126,28 +151,30 @@ JobManager::scheduler () return; } - BOOST_FOREACH (shared_ptr i, _jobs) { + if (!_paused) { + BOOST_FOREACH (shared_ptr i, _jobs) { - if (!i->finished ()) { - active_job = i->json_name (); - } + if (!i->finished ()) { + active_job = i->json_name (); + } - if (i->running ()) { - /* Something is already happening */ - break; - } + if (i->running ()) { + /* Something is already happening */ + break; + } - if (i->is_new()) { - i->start (); - /* Only start one job at once */ - break; + if (i->is_new()) { + i->start (); + /* Only start one job at once */ + break; + } } } } if (active_job != _last_active_job) { + emit (boost::bind (boost::ref (ActiveJobsChanged), _last_active_job, active_job)); _last_active_job = active_job; - emit (boost::bind (boost::ref (ActiveJobsChanged), active_job)); } dcpomatic_sleep (1); @@ -176,27 +203,138 @@ void JobManager::analyse_audio ( shared_ptr film, shared_ptr playlist, + bool from_zero, boost::signals2::connection& connection, function ready ) { - shared_ptr job; - { boost::mutex::scoped_lock lm (_mutex); BOOST_FOREACH (shared_ptr i, _jobs) { shared_ptr a = dynamic_pointer_cast (i); - if (a && film->audio_analysis_path (a->playlist ()) == film->audio_analysis_path (playlist)) { + if (a && a->playlist () == playlist) { i->when_finished (connection, ready); return; } } + } + + shared_ptr job; - job.reset (new AnalyseAudioJob (film, playlist)); + { + boost::mutex::scoped_lock lm (_mutex); + + job.reset (new AnalyseAudioJob (film, playlist, from_zero)); connection = job->Finished.connect (ready); _jobs.push_back (job); } emit (boost::bind (boost::ref (JobAdded), weak_ptr (job))); } + +void +JobManager::increase_priority (shared_ptr job) +{ + bool changed = false; + + { + boost::mutex::scoped_lock lm (_mutex); + list >::iterator last = _jobs.end (); + for (list >::iterator i = _jobs.begin(); i != _jobs.end(); ++i) { + if (*i == job && last != _jobs.end()) { + swap (*i, *last); + changed = true; + break; + } + last = i; + } + } + + if (changed) { + priority_changed (); + } +} + +void +JobManager::priority_changed () +{ + { + boost::mutex::scoped_lock lm (_mutex); + + bool first = true; + BOOST_FOREACH (shared_ptr i, _jobs) { + if (first) { + if (i->is_new ()) { + i->start (); + } else if (i->paused_by_priority ()) { + i->resume (); + } + first = false; + } else { + if (i->running ()) { + i->pause_by_priority (); + } + } + } + } + + emit (boost::bind (boost::ref (JobsReordered))); +} + +void +JobManager::decrease_priority (shared_ptr job) +{ + bool changed = false; + + { + boost::mutex::scoped_lock lm (_mutex); + for (list >::iterator i = _jobs.begin(); i != _jobs.end(); ++i) { + list >::iterator next = i; + ++next; + if (*i == job && next != _jobs.end()) { + swap (*i, *next); + changed = true; + break; + } + } + } + + if (changed) { + priority_changed (); + } +} + +void +JobManager::pause () +{ + boost::mutex::scoped_lock lm (_mutex); + + if (_paused) { + return; + } + + BOOST_FOREACH (shared_ptr i, _jobs) { + if (i->pause_by_user()) { + _paused_job = i; + } + } + + _paused = true; +} + +void +JobManager::resume () +{ + boost::mutex::scoped_lock lm (_mutex); + if (!_paused) { + return; + } + + if (_paused_job) { + _paused_job->resume (); + } + + _paused_job.reset (); + _paused = false; +}