void JobManager::DoSchedule(InternalJob::Pointer job,
Poco::Timestamp::TimeDiff delay)
{
Poco::ScopedLock<Poco::Mutex> managerLock(m_mutex);
//job may have been canceled already
int state = job->InternalGetState();
if (state != InternalJob::ABOUT_TO_SCHEDULE && state != Job::SLEEPING)
return;
//if it's a decoration job with no rule, don't run it right now if the system is busy
if (job->GetPriority() == Job::DECORATE && job->GetRule() == 0)
{
Poco::Timestamp::TimeDiff tmp_minDelay = m_running.size() * 100;
delay = std::max(delay, tmp_minDelay);
}
if (delay > 0)
{
job->SetStartTime(Poco::Timestamp() + delay * 100);
InternalJob::Pointer sptr_job(job);
ChangeState(sptr_job, Job::SLEEPING);
}
else
{
job->SetStartTime(Poco::Timestamp() + DelayFor(job->GetPriority()) * 100);
job->SetWaitQueueStamp(m_waitQueueCounter++);
InternalJob::Pointer sptr_job(job);
ChangeState(sptr_job, Job::WAITING);
}
}
bool InternalJob::IsConflicting(InternalJob::Pointer otherJob) const
{
ISchedulingRule::Pointer otherRule = otherJob->GetRule();
if (sptr_schedulingRule.GetPointer() == 0 || otherRule.GetPointer() == 0)
return false;
// TODO MultiRule: extend the IsConflicting (...) method with MultiRule
// if one of the rules is a compound rule, it must be asked the question.
//if (schedulingRule.GetClass() == MultiRule.class)
// return schedulingRule.IsConflicting(otherRule);
return otherRule->IsConflicting(sptr_schedulingRule);
}
InternalJob::Pointer JobManager::FindBlockingJob(InternalJob::Pointer waitingJob)
{
if (waitingJob->GetRule() == 0)
return InternalJob::Pointer(nullptr);
{
Poco::ScopedLock<Poco::Mutex> managerLock (m_mutex);
if (m_running.empty() )
{
InternalJob::Pointer dummy;
return (dummy);
}
//check the running jobs
bool hasBlockedJobs = false;
QSet<InternalJob::Pointer>::Iterator it;
for ( it = m_running.begin(); it != m_running.end(); it ++ )
{
InternalJob::Pointer sptr_job = *it ++;
if (waitingJob->IsConflicting(sptr_job))
return sptr_job;
if (!hasBlockedJobs)
hasBlockedJobs = sptr_job->Previous() != 0;
}
// there are no blocked jobs, so we are done
if (!hasBlockedJobs)
{
InternalJob::Pointer dummy;
return (dummy);
}
//check all jobs blocked by running jobs
QSet<InternalJob::Pointer>::Iterator it_blocked;
for( it_blocked = m_running.begin(); it_blocked != m_running.end(); it_blocked ++ )
{
InternalJob::Pointer sptr_job = *it_blocked ++;
while (true)
{
sptr_job = sptr_job->Previous();
if (sptr_job == 0)
break;
if (waitingJob->IsConflicting(sptr_job))
return sptr_job;
}
}
}
InternalJob::Pointer sptr_null;
return (sptr_null);
}