本文整理汇总了Python中common.CpuSnapshot类的典型用法代码示例。如果您正苦于以下问题：Python CpuSnapshot类的具体用法？Python CpuSnapshot怎么用？Python CpuSnapshot使用的例子？那么, 这里精选的类代码示例或许可以为您提供帮助。
在下文中一共展示了CpuSnapshot类的15个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: HeadDoubleEasyScheduler
class HeadDoubleEasyScheduler(EasyBackfillScheduler):
def __init__(self, num_processors):
super(HeadDoubleEasyScheduler, self).__init__(num_processors)
self.cpu_snapshot = CpuSnapshot(num_processors)
def _schedule_head_of_list(self, current_time):
"Overriding parent method"
result = []
while True:
if len(self.unscheduled_jobs) == 0:
break
# check if the first job can be scheduled at current time
if (
self.cpu_snapshot.free_processors_available_at(current_time)
>= self.unscheduled_jobs[0].num_required_processors
):
job = self.unscheduled_jobs.pop(0)
job.predicted_run_time = 2 * job.user_estimated_run_time # doubling is done here
self.cpu_snapshot.assignJob(job, current_time)
result.append(job)
else:
# first job can't be scheduled
break
return result示例2: FcfsScheduler
class FcfsScheduler(Scheduler):
def __init__(self, options):
super(FcfsScheduler, self).__init__(options)
self.cpu_snapshot = CpuSnapshot(self.num_processors, options["stats"])
self.waiting_queue_of_jobs = []
def new_events_on_job_submission(self, job, current_time):
self.cpu_snapshot.archive_old_slices(current_time)
self.waiting_queue_of_jobs.append(job)
return [
JobStartEvent(current_time, job)
for job in self._schedule_jobs(current_time)
]
def new_events_on_job_termination(self, job, current_time):
self.cpu_snapshot.archive_old_slices(current_time)
self.cpu_snapshot.delTailofJobFromCpuSlices(job)
return [
JobStartEvent(current_time, job)
for job in self._schedule_jobs(current_time)
]
def _schedule_jobs(self, current_time):
result = []
while len(self.waiting_queue_of_jobs) > 0:
job = self.waiting_queue_of_jobs[0]
if self.cpu_snapshot.free_processors_available_at(current_time) >= job.num_required_processors:
self.waiting_queue_of_jobs.pop(0)
self.cpu_snapshot.assignJob(job, current_time)
result.append(job)
else:
break
return result示例3: __init__
def __init__(self, options):
super(EasyPlusPlusScheduler, self).__init__(options)
self.init_predictor(options)
self.init_corrector(options)
self.cpu_snapshot = CpuSnapshot(self.num_processors, options["stats"])
self.unscheduled_jobs = []示例4: TailDoubleEasyScheduler
class TailDoubleEasyScheduler(EasyBackfillScheduler):
""" This algorithm implements the algorithm in the paper of Tsafrir, Etzion, Feitelson, june 2007?
"""
def __init__(self, options):
super(TailDoubleEasyScheduler, self).__init__(options)
self.cpu_snapshot = CpuSnapshot(self.num_processors, options["stats"])
def _backfill_jobs(self, current_time):
"Overriding parent method"
if len(self.unscheduled_jobs) <= 1:
return []
result = []
first_job = self.unscheduled_jobs[0]
tail = list_copy(self.unscheduled_jobs[1:])
self.cpu_snapshot.assignJobEarliest(first_job, current_time)
for job in tail:
job.predicted_run_time = 2 * job.user_estimated_run_time # doubling is done here
if self.cpu_snapshot.canJobStartNow(job, current_time): # if job can be backfilled
self.unscheduled_jobs.remove(job)
self.cpu_snapshot.assignJob(job, current_time)
result.append(job)
else:
job.predicted_run_time = job.user_estimated_run_time # undoubling is done here
self.cpu_snapshot.delJobFromCpuSlices(first_job)
return result示例5: EasySJBFScheduler
class EasySJBFScheduler(EasyBackfillScheduler):
""" This algorithm implements the algorithm in the paper of Tsafrir, Etzion, Feitelson, june 2007?
"""
def __init__(self, num_processors):
super(EasySJBFScheduler, self).__init__(num_processors)
self.cpu_snapshot = CpuSnapshot(num_processors)
def _backfill_jobs(self, current_time):
"Overriding parent method"
if len(self.unscheduled_jobs) <= 1:
return []
result = []
first_job = self.unscheduled_jobs[0]
tail = list_copy(self.unscheduled_jobs[1:])
tail_of_jobs_by_sjf_order = sorted(tail, key=sjf_sort_key)
self.cpu_snapshot.assignJobEarliest(first_job, current_time)
for job in tail_of_jobs_by_sjf_order:
if self.cpu_snapshot.canJobStartNow(job, current_time):
self.unscheduled_jobs.remove(job)
self.cpu_snapshot.assignJob(job, current_time)
result.append(job)
self.cpu_snapshot.delJobFromCpuSlices(first_job)
return result示例6: ReverseEasyScheduler
class ReverseEasyScheduler(EasyBackfillScheduler):
def __init__(self, options):
super(ReverseEasyScheduler, self).__init__(options)
self.cpu_snapshot = CpuSnapshot(self.num_processors, options["stats"])
def _backfill_jobs(self, current_time):
"Overriding parent method"
if len(self.unscheduled_jobs) <= 1:
return []
result = []
first_job = self.unscheduled_jobs[0]
tail = list_copy(self.unscheduled_jobs[1:])
tail_of_jobs_by_reverse_order = sorted(tail, key=latest_sort_key)
self.cpu_snapshot.assignJobEarliest(first_job, current_time)
for job in tail_of_jobs_by_reverse_order:
if self.cpu_snapshot.canJobStartNow(job, current_time):
self.unscheduled_jobs.remove(job)
self.cpu_snapshot.assignJob(job, current_time)
result.append(job)
self.cpu_snapshot.delJobFromCpuSlices(first_job)
return result示例7: ShrinkingEasyScheduler
class ShrinkingEasyScheduler(EasyBackfillScheduler):
""" This "toy" algorithm follows an the paper of Tsafrir, Etzion, Feitelson, june 2007
"""
def __init__(self, num_processors):
super(ShrinkingEasyScheduler, self).__init__(num_processors)
self.cpu_snapshot = CpuSnapshot(num_processors)
self.unscheduled_jobs = []
def new_events_on_job_submission(self, job, current_time):
if job.user_estimated_run_time > 1:
job.predicted_run_time = int(job.user_estimated_run_time / 2)
else:
job.predicted_run_time = 1
return super(ShrinkingEasyScheduler, self).new_events_on_job_submission(job, current_time)
def new_events_on_job_under_prediction(self, job, current_time):
assert job.predicted_run_time <= job.user_estimated_run_time
self.cpu_snapshot.assignTailofJobToTheCpuSlices(job)
return []示例8: LogScheduler
class LogScheduler(Scheduler):
def __init__(self, num_processors):
super(LogScheduler, self).__init__(num_processors)
self.cpu_snapshot = CpuSnapshot(num_processors)
self.waiting_queue_of_jobs = []
def new_events_on_job_submission(self, job, current_time):
self.cpu_snapshot.archive_old_slices(current_time)
result = []
#self.waiting_queue_of_jobs.append(job)
result.append(JobStartEvent(current_time+job.actual_wait_time, job))
#return [
# JobStartEvent(current_time, job)
# for job in self._log_schedule_jobs(current_time)
#]
return result
def new_events_on_job_termination(self, job, current_time):
self.cpu_snapshot.archive_old_slices(current_time)
self.cpu_snapshot.delTailofJobFromCpuSlices(job)
return []
"""return [
JobStartEvent(current_time, job)
for job in self._log_schedule_jobs(current_time)
]"""
def _schedule_jobs(self, current_time):
result = []
while len(self.waiting_queue_of_jobs) > 0:
job = self.waiting_queue_of_jobs[0]
if self.cpu_snapshot.free_processors_available_at(current_time) >= job.num_required_processors:
self.waiting_queue_of_jobs.pop(0)
self.cpu_snapshot.assignJob(job, current_time)
result.append(job)
else:
break
return result
def _log_schedule_jobs(self, current_time): #by Siddharth
result = []
return result
"""while len(self.waiting_queue_of_jobs) > 0:开发者ID:kruthikavishwanath，项目名称:project-to-predict-wait-times-in-tyrone-cluster，代码行数:44，代码来源:log_scheduler.py
示例9: ShrinkingEasyScheduler
class ShrinkingEasyScheduler(EasyBackfillScheduler):
""" This "toy" algorithm follows an the paper of Tsafrir, Etzion, Feitelson, june 2007
"""
I_NEED_A_PREDICTOR = True
def __init__(self, options):
super(ShrinkingEasyScheduler, self).__init__(options)
self.cpu_snapshot = CpuSnapshot(self.num_processors, options["stats"])
self.unscheduled_jobs = []
def new_events_on_job_submission(self, job, current_time):
if job.user_estimated_run_time > 1:
job.predicted_run_time = int(job.user_estimated_run_time / 2)
else:
job.predicted_run_time = 1
return super(ShrinkingEasyScheduler, self).new_events_on_job_submission(job, current_time)
def new_events_on_job_under_prediction(self, job, current_time):
pass #assert job.predicted_run_time <= job.user_estimated_run_time
new_predicted_run_time = common_correctors.reqtime(job, current_time)
self.cpu_snapshot.assignTailofJobToTheCpuSlices(job, new_predicted_run_time)
job.predicted_run_time = new_predicted_run_time
return [JobStartEvent(current_time, job)]示例10: __init__
def __init__(self, num_processors, threshold = 0.2, window_size=150):
super(OrigProbabilisticEasyScheduler, self).__init__(num_processors)
self.threshold = threshold
self.window_size = window_size # a parameter for the distribution
self.cpu_snapshot = CpuSnapshot(num_processors)
self.user_distribution = {}
self.unscheduled_jobs = []
self.currently_running_jobs = []
#self.work_list = [[None for i in xrange(self.num_processors+1)] for j in xrange(self.num_processors+1)]
self.M = {}
for c in xrange(self.num_processors+1):
for n in xrange(self.num_processors+1):
self.M[c, n] = 0.0
self.max_user_rounded_estimated_run_time = 0
self.prev_max_user_rounded_estimated_run_time = 0示例11: OrigProbabilisticEasyScheduler
class OrigProbabilisticEasyScheduler(Scheduler):
""" This algorithm implements a version of Feitelson and Nissimov, June 2007
"""
def __init__(self, num_processors, threshold = 0.2, window_size=150):
super(OrigProbabilisticEasyScheduler, self).__init__(num_processors)
self.threshold = threshold
self.window_size = window_size # a parameter for the distribution
self.cpu_snapshot = CpuSnapshot(num_processors)
self.user_distribution = {}
self.unscheduled_jobs = []
self.currently_running_jobs = []
#self.work_list = [[None for i in xrange(self.num_processors+1)] for j in xrange(self.num_processors+1)]
self.M = {}
for c in xrange(self.num_processors+1):
for n in xrange(self.num_processors+1):
self.M[c, n] = 0.0
self.max_user_rounded_estimated_run_time = 0
self.prev_max_user_rounded_estimated_run_time = 0
def new_events_on_job_submission(self, job, current_time):
# print "arrived:", job
rounded_up_estimated_time = _round_time_up(job.user_estimated_run_time)
if rounded_up_estimated_time > self.max_user_rounded_estimated_run_time:
self.prev_max_user_rounded_estimated_run_time = self.max_user_rounded_estimated_run_time
self.max_user_rounded_estimated_run_time = rounded_up_estimated_time
if not self.user_distribution.has_key(job.user_id):
self.user_distribution[job.user_id] = Distribution(job, self.window_size)
self.user_distribution[job.user_id].touch(2*self.max_user_rounded_estimated_run_time)
if self.prev_max_user_rounded_estimated_run_time < self.max_user_rounded_estimated_run_time:
for tmp_job in self.currently_running_jobs:
self.user_distribution[tmp_job.user_id].touch(2*self.max_user_rounded_estimated_run_time)
self.cpu_snapshot.archive_old_slices(current_time)
self.unscheduled_jobs.append(job)
return [
JobStartEvent(current_time, job)
for job in self._schedule_jobs(current_time)
]
def new_events_on_job_termination(self, job, current_time):
self.user_distribution[job.user_id].add_job(job)
self.currently_running_jobs.remove(job)
self.cpu_snapshot.archive_old_slices(current_time)
self.cpu_snapshot.delTailofJobFromCpuSlices(job)
return [
JobStartEvent(current_time, job)
for job in self._schedule_jobs(current_time)
]
def _schedule_jobs(self, current_time):
"Schedules jobs that can run right now, and returns them"
jobs = self._schedule_head_of_list(current_time)
jobs += self._backfill_jobs(current_time)
return jobs
def _schedule_head_of_list(self, current_time):
result = []
while True:
if len(self.unscheduled_jobs) == 0:
break
# Try to schedule the first job
if self.cpu_snapshot.free_processors_available_at(current_time) >= self.unscheduled_jobs[0].num_required_processors:
job = self.unscheduled_jobs.pop(0)
self.currently_running_jobs.append(job)
self.cpu_snapshot.assignJob(job, current_time)
result.append(job)
else:
# first job can't be scheduled
break
return result
def _backfill_jobs(self, current_time):
if len(self.unscheduled_jobs) <= 1:
return []
result = []
first_job = self.unscheduled_jobs[0]
tail = list_copy(self.unscheduled_jobs[1:])
for job in tail:
if self.can_be_probabilistically_backfilled(job, current_time):
self.unscheduled_jobs.remove(job)
self.currently_running_jobs.append(job)
self.cpu_snapshot.assignJob(job, current_time)
result.append(job)
return result
#.........这里部分代码省略.........
示例12: __init__
def __init__(self, options):
super(ConservativeScheduler, self).__init__(options)
self.cpu_snapshot = CpuSnapshot(self.num_processors, options["stats"])
self.unfinished_jobs_by_submit_time = []示例13: ConservativeScheduler
class ConservativeScheduler(Scheduler):
def __init__(self, options):
super(ConservativeScheduler, self).__init__(options)
self.cpu_snapshot = CpuSnapshot(self.num_processors, options["stats"])
self.unfinished_jobs_by_submit_time = []
def new_events_on_job_submission(self, job, current_time):
self.cpu_snapshot.archive_old_slices(current_time)
self.unfinished_jobs_by_submit_time.append(job)
self.cpu_snapshot.assignJobEarliest(job, current_time)
return [ JobStartEvent(job.start_to_run_at_time, job) ]
def new_events_on_job_termination(self, job, current_time):
""" Here we delete the tail of job if it was ended before the duration declaration.
It then reschedules the remaining jobs and returns a collection of new termination events
(using the dictionary data structure) """
self.cpu_snapshot.archive_old_slices(current_time)
self.unfinished_jobs_by_submit_time.remove(job)
self.cpu_snapshot.delTailofJobFromCpuSlices(job)
return self._reschedule_jobs(current_time)
def _reschedule_jobs(self, current_time):
newEvents = []
for job in self.unfinished_jobs_by_submit_time:
if job.start_to_run_at_time <= current_time:
continue # job started to run before, so it cannot be rescheduled (preemptions are not allowed)
prev_start_to_run_at_time = job.start_to_run_at_time
self.cpu_snapshot.delJobFromCpuSlices(job)
self.cpu_snapshot.assignJobEarliest(job, current_time)
assert prev_start_to_run_at_time >= job.start_to_run_at_time
if prev_start_to_run_at_time != job.start_to_run_at_time:
newEvents.append( JobStartEvent(job.start_to_run_at_time, job) )
return newEvents示例14: __init__
def __init__(self, num_processors):
super(HeadDoubleEasyScheduler, self).__init__(num_processors)
self.cpu_snapshot = CpuSnapshot(num_processors)示例15: EasyPlusPlusScheduler
class EasyPlusPlusScheduler(Scheduler):
""" This algorithm implements the algorithm in the paper of Tsafrir, Etzion, Feitelson, june 2007?
"""
I_NEED_A_PREDICTOR = True
def __init__(self, options):
super(EasyPlusPlusScheduler, self).__init__(options)
self.init_predictor(options)
self.init_corrector(options)
self.cpu_snapshot = CpuSnapshot(self.num_processors, options["stats"])
self.unscheduled_jobs = []
def new_events_on_job_submission(self, job, current_time):
self.cpu_snapshot.archive_old_slices(current_time)
self.predictor.predict(job, current_time, self.running_jobs)
if not hasattr(job,"initial_prediction"):
job.initial_prediction=job.predicted_run_time
self.unscheduled_jobs.append(job)
return [
JobStartEvent(current_time, job)
for job in self._schedule_jobs(current_time)
]
def new_events_on_job_termination(self, job, current_time):
self.predictor.fit(job, current_time)
if self.corrector.__name__=="ninetynine":
self.pestimator.fit(job.actual_run_time/job.user_estimated_run_time)
self.cpu_snapshot.archive_old_slices(current_time)
self.cpu_snapshot.delTailofJobFromCpuSlices(job)
return [
JobStartEvent(current_time, job)
for job in self._schedule_jobs(current_time)
]
def new_events_on_job_under_prediction(self, job, current_time):
pass #assert job.predicted_run_time <= job.user_estimated_run_time
if not hasattr(job,"num_underpredict"):
job.num_underpredict = 0
else:
job.num_underpredict += 1
if self.corrector.__name__=="ninetynine":
new_predicted_run_time = self.corrector(self.pestimator,job,current_time)
else:
new_predicted_run_time = self.corrector(job, current_time)
#set the new predicted runtime
self.cpu_snapshot.assignTailofJobToTheCpuSlices(job, new_predicted_run_time)
job.predicted_run_time = new_predicted_run_time
return [JobStartEvent(current_time, job)]
def _schedule_jobs(self, current_time):
"Schedules jobs that can run right now, and returns them"
jobs = self._schedule_head_of_list(current_time)
jobs += self._backfill_jobs(current_time)
return jobs
def _schedule_head_of_list(self, current_time):
result = []
while True:
if len(self.unscheduled_jobs) == 0:
break
# Try to schedule the first job
if self.cpu_snapshot.free_processors_available_at(current_time) >= self.unscheduled_jobs[0].num_required_processors:
job = self.unscheduled_jobs.pop(0)
self.cpu_snapshot.assignJob(job, current_time)
result.append(job)
else:
# first job can't be scheduled
break
return result
def _backfill_jobs(self, current_time):
if len(self.unscheduled_jobs) <= 1:
return []
result = []
first_job = self.unscheduled_jobs[0]
tail = list_copy(self.unscheduled_jobs[1:])
tail_of_jobs_by_sjf_order = sorted(tail, key=sjf_sort_key)
self.cpu_snapshot.assignJobEarliest(first_job, current_time)
for job in tail_of_jobs_by_sjf_order:
if self.cpu_snapshot.canJobStartNow(job, current_time):
job.is_backfilled = 1
#.........这里部分代码省略.........