IProgressMonitor::Pointer JobManager::CreateMonitor(InternalJob::Pointer sptr_job, IProgressMonitor::Pointer group, int ticks)
{
{
Poco::ScopedLock<Poco::Mutex> managerLock(m_mutex);
//group must be set before the job is scheduled
//this includes the ABOUT_TO_SCHEDULE state, during which it is still
//valid to set the progress monitor
if (sptr_job->GetState() != Job::NONE)
{
IProgressMonitor::Pointer dummy(nullptr);
return dummy;
}
IProgressMonitor::Pointer sptr_monitor(nullptr);
if (m_sptr_progressProvider != 0)
sptr_monitor = m_sptr_progressProvider->CreateMonitor(sptr_job.Cast<Job>() , group, ticks);
if (sptr_monitor == 0)
{
// return a default NullprogressMonitor
NullProgressMonitor::Pointer sptr_defaultMonitor(new NullProgressMonitor() );
return sptr_defaultMonitor;
}
return sptr_monitor;
}
}
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);
}
}
Job::Pointer JobManager::NextJob()
{
{
Poco::ScopedLock<Poco::Mutex> managerLock(m_mutex);
//do nothing if the job manager is suspended
if (m_suspended)
return Job::Pointer(nullptr);
// tickle the sleep queue to see if anyone wakes up
Poco::Timestamp now;
InternalJob::Pointer ptr_job = m_JobQueueSleeping.Peek();
while (ptr_job != 0 && ptr_job->GetStartTime() < now)
{
// a job that slept to long is set a new start time and is put into the waiting queue
ptr_job->SetStartTime(now + DelayFor(ptr_job->GetPriority()));
ptr_job->SetWaitQueueStamp(m_waitQueueCounter++);
InternalJob::Pointer sptr_job(ptr_job);
ChangeState(sptr_job, Job::WAITING);
ptr_job = m_JobQueueSleeping.Peek();
}
//process the wait queue until we find a job whose rules are satisfied.
while ((ptr_job = m_JobQueueWaiting.Peek()) != 0)
{
InternalJob::Pointer sptr_job(ptr_job);
InternalJob::Pointer sptr_blocker = FindBlockingJob(sptr_job);
if (sptr_blocker == 0)
break;
//queue this job after the job that's blocking it
ChangeState(sptr_job, InternalJob::BLOCKED);
//assert job does not already belong to some other data structure
//Assert.isTrue(job.next() == null);
//Assert.isTrue(job.previous() == null);
sptr_blocker->AddLast(ptr_job);
}
// the job to run must be in the running list before we exit
// the sync block, otherwise two jobs with conflicting rules could start at once
if (ptr_job != 0)
{
InternalJob::Pointer sptr_job(ptr_job);
ChangeState(sptr_job, InternalJob::ABOUT_TO_RUN);
}
return ptr_job.Cast<Job> ();
}
}
~RangePreserver() {
stdx::lock_guard<stdx::mutex> managerLock(_metadataManager->_managerLock);
invariant(_metadataTracker->usageCounter != 0);
if (--_metadataTracker->usageCounter == 0) {
// MetadataManager doesn't care which usageCounter went to zero. It just retires all
// that are older than the oldest metadata still in use by queries (some start out at
// zero, some go to zero but can't be expired yet).
//
// Note that new instances of ScopedCollectionMetadata may get attached to
// _metadata.back(), so its usage count can increase from zero, unlike other reference
// counts.
_metadataManager->_retireExpiredMetadata(managerLock);
}
}
void remove(MachineThreads* machineThreads)
{
MutexLocker managerLock(m_lock);
auto recordedMachineThreads = m_set.take(machineThreads);
RELEASE_ASSERT(recordedMachineThreads = machineThreads);
}
void add(MachineThreads* machineThreads)
{
MutexLocker managerLock(m_lock);
m_set.add(machineThreads);
}