コード例 #1
0
ファイル: matrix.py プロジェクト: nikmonkov/pymatrix
 def s(self):
     """
     Формирование матрицы коэффициентов системы
     :return:
     """
     result = np.zeros(
         [2 * self.M1 * self.K + self.M + self.M1 + 1, self.M1 * (2 * self.K - 1) + self.M + 2 * self.M1 + 1],
         complex)
     w = self.wf(0)
     for n in xrange(0, self.M + 1):
         for m in xrange(0, self.M + 1):
             result[n, m] = delta(n, m)
             result[n, m + self.M1] = - w[n, m]
             result[n, m + 2 * self.M1] = - w[n, m]
             result[n + self.M1, m] = - w.transpose()[n, m]
             result[n + self.M1, m + self.M1] = - delta(n, m)
             result[n + self.M1, m + 2 * self.M1] = delta(n, m)
     if self.K > 1:
         for j in xrange(1, self.K):
             w = self.wf(j)
             p1 = self.psi1(j)
             p2 = self.psi2(j)
             for n in xrange(0, self.M + 1):
                 for m in xrange(0, self.M + 1):
                     result[2 * self.M1 * j + n, 2 * self.M1 * j + m - self.M1] = p1[n, m]
                     result[2 * self.M1 * j + n, 2 * self.M1 * j + m + 0] = p2[n, m]
                     result[2 * self.M1 * j + n, 2 * self.M1 * j + m + 1 * self.M1] = - w[n, m]
                     result[2 * self.M1 * j + n, 2 * self.M1 * j + m + 2 * self.M1] = - w[n, m]
                     result[2 * self.M1 * j + n + self.M1, 2 * self.M1 * j + m - self.M1] = \
                         np.dot(w.transpose(), p1)[n, m]
                     result[2 * self.M1 * j + n + self.M1, 2 * self.M1 * j + m + 0] = np.dot(- w.transpose(), p2)[
                         n, m]
                     result[2 * self.M1 * j + n + self.M1, 2 * self.M1 * j + m + 1 * self.M1] = - delta(n, m)
                     result[2 * self.M1 * j + n + self.M1, 2 * self.M1 * j + m + 2 * self.M1] = delta(n, m)
     w = self.wf(self.K)
     p1 = self.psi1(self.K)
     p2 = self.psi2(self.K)
     for n in xrange(0, self.M + 1):
         for m in xrange(0, self.M + 1):
             result[2 * self.M1 * self.K + n, 1 * self.M1 * (2 * self.K - 1) + m - 0] = p1[n, m]
             result[2 * self.M1 * self.K + n, 1 * self.M1 * (2 * self.K - 1) + m + 1 * self.M1] = p2[n, m]
             result[2 * self.M1 * self.K + n, 1 * self.M1 * (2 * self.K - 1) + m + 2 * self.M1] = - w[n, m]
             result[2 * self.M1 * self.K + n + self.M1, 1 * self.M1 * (2 * self.K - 1) + m - 0] = \
                 np.dot(w.transpose(), p1)[n, m]
             result[2 * self.M1 * self.K + n + self.M1, 1 * self.M1 * (2 * self.K - 1) + m + 1 * self.M1] = \
                 np.dot(- w.transpose(), p2)[n, m]
             result[2 * self.M1 * self.K + n + self.M1, 1 * self.M1 * (2 * self.K - 1) + m + 2 * self.M1] = - delta(
                 m, n)
     return result
コード例 #2
0
def calcula_topographic_error(mapa):
	
	erro = 0
	for objeto in mapa.objetos:
		cluster1 = objeto.cluster
		cluster2 = objeto.segundo
		
		distancia = util.delta(cluster1.point, cluster2.point)
		if distancia > 2:
			erro += 1
			
	tam = len(mapa.objetos)
	erro_topografico = erro/tam
	
	return erro_topografico
コード例 #3
0
ファイル: entities.py プロジェクト: filipjs/Simulator
 def __repr__(self):
     st = self.started and self.start_time
     end = self.completed and self.end_time
     s = 'Job {} [{} -> {} -> {} : run {} limit {} proc {}]'
     return s.format(self.ID, delta(self.submit), delta(st), delta(end),
             delta(self.run_time), delta(self.time_limit), self.proc)
コード例 #4
0
ファイル: entities.py プロジェクト: filipjs/Simulator
 def __repr__(self):
     s = 'Camp {} {} [created {} work {} left {} : jobs {} {}]'
     return s.format(self.ID, self.user.ID, delta(self.created),
             delta(self.workload), delta(self.time_left),
             len(self.active_jobs), len(self.completed_jobs))
コード例 #5
0
ファイル: simulator.py プロジェクト: kmrz/Simulator
    def run(self):
        """
		Proceed with the simulation.
		Return a list of encountered events.
		"""

        # Magic value taken from slurm/multifactor plugin.
        self._decay_factor = 1 - (0.693 / self._settings.decay)
        # Note:
        #   The CPU usage decay is always applied after each event.
        #   There is also a dummy `force_decay` event inserted into
        #   the queue to force the calculations in case the gap
        #   between consecutive events would be too long.
        # TODO ZAMIENIC APPLY DECAY NA BACKGROUND THREAD TAK SAMO JAK BACKFILLING?!?!?!
        # TODO WTEDY BEDZIE TRZEBA TRZYMAC "TEMPORARY" USAGE GDZIES ODDZIELNIE I GO DODAWAC
        # TODO DO GLOWNEGO DOPIERO PRZY URUCHOMIENIU TEGO "THREADA"
        self._force_period = 60 * 5

        self._initialize()

        sub_iter = sub_count = 0
        sub_total = len(self._block)
        end_iter = 0

        schedule = backfill = False
        instant_bf = self._settings.bf_depth and not self._settings.bf_interval

        # the first job submission is the simulation 'time zero'
        prev_event = self._block[0].submit
        self._diag.prev_util["time"] = prev_event

        visual_update = 60  # notify the user about the progress
        # TODO DODAC POZA CZASEM TEZ PROCENTOWO CO 25%
        next_visual = time.time() + visual_update

        while sub_iter < sub_total or not self._pq.empty():
            # We only need to keep two `new_job` events in the
            # queue at the same time (one to process, one to peek).
            while sub_iter < sub_total and sub_count < 2:
                self._pq.add(self._block[sub_iter].submit, Events.new_job, self._block[sub_iter])
                sub_iter += 1
                sub_count += 1
                # the queue cannot be empty here
            self._now, event, entity = self._pq.pop()

            if event != Events.force_decay:
                logging.debug("Time %s, event %s", delta(self._now), event)

                # Process the time skipped between events
                # before changing the state of the system.
            diff = self._now - prev_event
            if diff:
                self._virt_first_stage(diff)
                self._real_first_stage(diff)
                # The default flow is to redistribute the virtual
                # time and compute new campaign ends (and maybe do
                # a scheduling / backfilling pass in the between).
            virt_second = True
            campaigns = True

            if event == Events.new_job:
                # check if the job is runnable
                if self._manager.runnable(entity):
                    self._new_job_event(entity)
                    schedule = True
                else:
                    self._diag.skipped += 1
                    end_iter += 1
                sub_count -= 1
            elif event == Events.job_end:
                self._job_end_event(entity)
                end_iter += 1
                schedule = True
            elif event == Events.estimate_end:
                self._estimate_end_event(entity)
            elif event == Events.bf_run:
                backfill = True
            elif event == Events.campaign_end:
                # We need to redistribute the virtual time now,
                # so the campaign can actually end.
                self._virt_second_stage()
                virt_second = False  # already done
                campaigns = self._camp_end_event(entity)
            elif event == Events.force_decay:
                self._diag.forced += 1
                virt_second = False  # no need to do it now
                campaigns = False  # no change to campaign ends
            else:
                raise Exception("unknown event")

                # update event timer
            prev_event = self._now

            if not self._pq.empty():
                # We need to process all the events that happen at
                # the same time *AND* change the campaign workloads
                # before we can continue further.
                next_time, next_event, _ = self._pq.peek()
                if next_time == self._now and next_event < Events.bf_run:
                    continue

            if virt_second:
                self._virt_second_stage()

            if schedule:
                scheduled_jobs = self._schedule(bf_mode=False)
                self._diag.sched_jobs += scheduled_jobs
                self._diag.sched_pass += 1
                self._update_util()  # must be after schedule
                schedule = False
                if instant_bf:
                    backfill = True

            if backfill:
                backfilled_jobs = self._schedule(bf_mode=True)
                self._diag.bf_jobs += backfilled_jobs
                self._diag.bf_pass += 1
                self._update_util()  # must be after schedule
                backfill = False

            if campaigns:
                self._update_camp_estimates()

                # add periodically occurring events
            if event < Events.bf_run:
                self._next_backfill(self._now)
            elif event == Events.bf_run and backfilled_jobs:
                self._next_backfill(self._now + 1)

            if end_iter < sub_total:
                # There are still jobs in the simulation
                # so we need an accurate usage.
                assert not self._pq.empty(), "infinite loop"
                self._next_force_decay()

                # progress report
            if time.time() > next_visual:
                next_visual += visual_update
                comp = float(sub_iter + end_iter) / (2 * sub_total)
                msg = "Block {:2} scheduler {}: {} completed {:.2f}%"
                logging.info(
                    msg.format(self._block.number, self._parts.scheduler, time.strftime("%H:%M:%S"), comp * 100)
                )
                if self._waiting_jobs:
                    top_prio = self._waiting_jobs[-1].proc
                else:
                    top_prio = -1
                logging.info(
                    "events {} {}  |  cpus {} {}  |  waiting jobs {} {}"
                    "  |  stats {:.2f} {:.2f} {:.2f}".format(
                        sub_iter,
                        end_iter,
                        self._stats.cpu_used,
                        self._cpu_free,
                        len(self._waiting_jobs),
                        top_prio,
                        (self._diag.avg_util["sum"] / self._diag.avg_util["period"]),
                        self._diag.sched_jobs / float(sub_iter),
                        self._diag.bf_jobs / float(sub_iter),
                    )
                )

        self._finalize()
        # Results for each user should be in this order:
        #  1) job ends (this is done during simulation)
        #  2) camp ends
        #  3) user stats
        for u in self._users.itervalues():
            for i, c in enumerate(u.completed_camps):
                self._store_camp_ended(c)
            self._store_user_stats(u)

            # merge the results
        self._results.append(self._compressor.flush())
        self._results = "".join(self._results)
        return self._results, self._diag
コード例 #6
0
ファイル: cluster_managers.py プロジェクト: filipjs/Simulator
 def __repr__(self):
     s = '[{}, {}] last {} first {}\n\tavail {}\n\trsrvd {}'
     return s.format(delta(self.begin), delta(self.end),
         self.job_ends, self.rsrv_starts,
         self.avail, self.reserved)
コード例 #7
0
ファイル: simulator.py プロジェクト: filipjs/Simulator
    def run(self):
        """
        Proceed with the simulation.
        Return a list of encountered events.
        """

        # Magic value taken from slurm/multifactor plugin.
        self._decay_factor = 1 - (0.693 / self._settings.decay)
        # Note:
        #   The CPU usage decay is always applied after each event.
        #   There is also a dummy `force_decay` event inserted into
        #   the queue to force the calculations in case the gap
        #   between consecutive events would be too long.
        self._force_period = 60 * 5

        self._initialize()

        sub_iter = sub_count = 0
        sub_total = len(self._block)
        end_iter = 0

        schedule = backfill = False
        instant_bf = (self._settings.bf_depth and
                      not self._settings.bf_interval)

        # the first job submission is the simulation 'time zero'
        prev_event = self._block[0].submit
        self._diag.prev_util['time'] = prev_event

        # time to notify the user about the simulation progress
        next_visual_update = time.time() + self._settings.update_time

        while sub_iter < sub_total or not self._pq.empty():
            # We only need to keep two `new_job` events in the
            # queue at the same time (one to process, one to peek).
            while sub_iter < sub_total and sub_count < 2:
                self._pq.add(
                    self._block[sub_iter].submit,
                    Events.new_job,
                    self._block[sub_iter]
                )
                sub_iter += 1
                sub_count += 1
            # the queue cannot be empty here
            self._now, event, entity = self._pq.pop()

            if event != Events.force_decay:
                logging.debug('Time %s, event %s', delta(self._now), event)

            # Process the time skipped between events
            # before changing the state of the system.
            diff = self._now - prev_event
            if diff:
                self._virt_first_stage(diff)
                self._real_first_stage(diff)
            # The default flow is to redistribute the virtual
            # time and compute new campaign ends (and maybe do
            # a scheduling / backfilling pass in the between).
            virt_second = True
            campaigns = True

            if event == Events.new_job:
                # check if the job is runnable
                if self._manager.runnable(entity):
                    self._new_job_event(entity)
                    schedule = True
                else:
                    self._diag.skipped += 1
                    end_iter += 1
                sub_count -= 1
            elif event == Events.job_end:
                self._job_end_event(entity)
                end_iter += 1
                schedule = True
            elif event == Events.estimate_end:
                self._estimate_end_event(entity)
            elif event == Events.bf_run:
                backfill = True
            elif event == Events.campaign_end:
                # We need to redistribute the virtual time now,
                # so the campaign can actually end.
                self._virt_second_stage()
                virt_second = False  # already done
                campaigns = self._camp_end_event(entity)
            elif event == Events.force_decay:
                self._diag.forced += 1
                virt_second = False  # no need to do it now
                campaigns = False  # no change to campaign ends
            else:
                raise Exception('unknown event')

            # update event timer
            prev_event = self._now

            if not self._pq.empty():
                # We need to process all the events that happen at
                # the same time *AND* change the campaign workloads
                # before we can continue further.
                next_time, next_event, _ = self._pq.peek()
                if (next_time == self._now and
                    next_event < Events.bf_run):
                    continue

            if virt_second:
                self._virt_second_stage()

            if schedule:
                scheduled_jobs = self._schedule(bf_mode=False)
                self._diag.sched_jobs += scheduled_jobs
                self._diag.sched_pass += 1
                self._update_util()  # must be after schedule
                schedule = False
                if instant_bf: backfill = True

            if backfill:
                backfilled_jobs = self._schedule(bf_mode=True)
                self._diag.bf_jobs += backfilled_jobs
                self._diag.bf_pass += 1
                self._update_util()  # must be after schedule
                backfill = False

            if campaigns:
                self._update_camp_estimates()

            # add periodically occurring events
            if event < Events.bf_run:
                self._next_backfill(self._now)
            elif event == Events.bf_run and backfilled_jobs:
                self._next_backfill(self._now + 1)

            if end_iter < sub_total:
                # There are still jobs in the simulation
                # so we need an accurate usage.
                assert not self._pq.empty(), 'infinite loop'
                self._next_force_decay()

            # progress report
            if time.time() > next_visual_update:
                completed = float(sub_iter + end_iter) / (2 * sub_total)
                self._log_progress(sub_iter, completed)
                next_visual_update += self._settings.update_time

        self._finalize()
        # Results for each user should be in this order:
        #  1) job ends (this is done during simulation)
        #  2) camp ends
        #  3) user stats
        for u in self._users.itervalues():
            for i, c in enumerate(u.completed_camps):
                self._store_camp_ended(c)
            self._store_user_stats(u)

        # merge the results
        self._results.append(self._compressor.flush())
        self._results = ''.join(self._results)
        return self._results, self._diag
コード例 #8
0
ファイル: matrix.py プロジェクト: nikmonkov/pymatrix
    def psi2(self, num):
        """

        :param num:
        :return:
        """
        result = np.zeros([self.M + 1, self.M + 1], complex)
        for n in xrange(0, self.M + 1):
            for m in xrange(0, self.M + 1):
                result[n, m] = (sp.e ** ((0 + 1j) * self.beta(num, n) * self.deltaL)) * delta(n, m)
        return result