class BasicProcessTreeBuilder(object):

    def __init__(self, drivingEngine, exp):
        self.drivingEngine = drivingEngine
        self.tree = ProcessTree(exp)

    # The parts common to the basic and advanced supercompilers.

    # If beta `instOf` alpha, we generalize beta by introducing
    # a let-expression, in order to make beta the same as alpha
    # (modulo variable names).

    def loopBack(self, beta, alpha):
        subst = matchAgainst(alpha.exp, beta.exp)
        bindings = list(subst.items())
        bindings.sort()
        letExp = Let(alpha.exp, bindings)
        self.tree.replaceSubtree(beta, letExp)

    # This function applies a driving step to the node's expression,
    # and, in general, adds children to the node.

    def expandNode(self, beta):
        branches = self.drivingEngine.drivingStep(beta.exp)
        self.tree.addChildren(beta, branches)

    # Basic supercompiler process tree builder

    def buildStep(self, beta):
        """
        This method is overridden in the advanced version of
        the process tree builder.
        """
        alpha = beta.findMoreGeneralAncestor()
        if alpha:
            self.loopBack(beta, alpha)
        else:
            self.expandNode(beta)

    def buildProcessTree(self, k):
        # Specifying k = -1 results in an unlimited building loop.
        while True:
            if k == 0:
                break
            k -= 1
            beta = self.tree.findUnprocessedNode()
            if not beta:
                break
            self.buildStep(beta)
Пример #2
0
class BasicProcessTreeBuilder(object):
    def __init__(self, drivingEngine, exp):
        self.drivingEngine = drivingEngine
        self.tree = ProcessTree(exp)

    # The parts common to the basic and advanced supercompilers.

    # If beta `instOf` alpha, we generalize beta by introducing
    # a let-expression, in order to make beta the same as alpha
    # (modulo variable names).

    def loopBack(self, beta, alpha):
        subst = matchAgainst(alpha.exp, beta.exp)
        bindings = list(subst.items())
        bindings.sort()
        letExp = Let(alpha.exp, bindings)
        self.tree.replaceSubtree(beta, letExp)

    # This function applies a driving step to the node's expression,
    # and, in general, adds children to the node.

    def expandNode(self, beta):
        branches = self.drivingEngine.drivingStep(beta.exp)
        self.tree.addChildren(beta, branches)

    # Basic supercompiler process tree builder

    def buildStep(self, beta):
        """
        This method is overridden in the advanced version of
        the process tree builder.
        """
        alpha = beta.findMoreGeneralAncestor()
        if alpha:
            self.loopBack(beta, alpha)
        else:
            self.expandNode(beta)

    def buildProcessTree(self, k):
        # Specifying k = -1 results in an unlimited building loop.
        while True:
            if k == 0:
                break
            k -= 1
            beta = self.tree.findUnprocessedNode()
            if not beta:
                break
            self.buildStep(beta)
Пример #3
0
def parse(writer, paths, prune, crop_after, annotate):
    state = parse_paths(writer, ParserState(), paths)
    if not state.valid():
        raise ParseError(
            "empty state: '%s' does not contain a valid bootchart" %
            ", ".join(paths))
    # Crop the chart to the end of the first idle period after the given
    # process
    if crop_after:
        idle = crop(writer, crop_after, state)
    else:
        idle = None
    # Annotate other times as the first start point of given process lists
    times = [idle]
    if annotate:
        for procnames in annotate:
            names = [x[:15] for x in procnames.split(",")]
            for proc in state.ps_stats.process_list:
                if proc.cmd in names:
                    times.append(proc.start_time)
                    break
            else:
                times.append(None)
    monitored_app = state.headers.get("profile.process")
    proc_tree = ProcessTree(writer, state.ps_stats, monitored_app, prune, idle)
    return (state.headers, state.cpu_stats, state.disk_stats, proc_tree, times)
Пример #4
0
    def __init__(self):
        super().__init__(title="Task manager")
        self.connection = None
        self.set_position(Gtk.WindowPosition.CENTER)
        self.set_size_request(1000, 500)
        master_box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
        self.add(master_box)
        hpaned = Gtk.Paned()
        master_box.add(hpaned)
        left_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
        right_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
        app_header = Gtk.Label(label='APPLICATIONS')
        self.proc_header = Gtk.Label(label='PROCESSES')
        left_box.pack_start(app_header, False, True, 0)
        right_box.pack_start(self.proc_header, False, True, 0)
        hpaned.add1(left_box)
        hpaned.add2(right_box)
        applications_tree_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
        self.applications_treeview = ApplicationTree()
        app_adj = Gtk.Adjustment()
        applications_scroll = Gtk.ScrolledWindow(app_adj)
        applications_scroll.set_size_request(400, 500)
        applications_scroll.add_with_viewport(self.applications_treeview)
        left_box.pack_start(applications_tree_box, False, True, 0)
        applications_tree_box.pack_start(applications_scroll, True, True, 0)
        proc_adj = Gtk.Adjustment()
        process_tree_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
        right_box.pack_start(process_tree_box, False, True, 0)
        self.process_scroll = Gtk.ScrolledWindow(proc_adj)
        self.process_scroll.set_size_request(600, 220)
        process_tree_box.pack_start(self.process_scroll, True, True, 0)
        self.process_treeview = ProcessTree()
        self.process_scroll.add_with_viewport(self.process_treeview)
        button_box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
        right_box.pack_end(button_box, False, True, 0)
        close_button = Gtk.Button(label="Close")
        close_button.connect("clicked", self.close_app)
        button_box.pack_start(close_button, True, True, 0)
        # self.freeze_button = FreezeButton()
        # self.freeze_button.connect('clicked', self.freeze)
        # button_box.pack_start(self.freeze_button, True, True, 0)
        self.proc_kill_button = ProcessKillButton()
        self.proc_kill_button.connect("clicked", self.kill_process)
        button_box.pack_start(self.proc_kill_button, True, True, 0)
        self.process_info_label = Gtk.Label()
        self.process_info_label.set_size_request(430, 210)
        self.process_info_label.set_selectable(True)
        self.process_info_label.set_line_wrap(True)
        self.info_header = Gtk.Label(label='DETAILED PROCESS INFO')
        right_box.pack_start(self.info_header, True, True, 0)
        keys_scrolled = Gtk.ScrolledWindow()
        self.keys_tree = InfoTree(1)
        keys_scrolled.add(self.keys_tree)
        info_scrolled = Gtk.ScrolledWindow()
        info_scrolled.set_size_request(430, 210)
        info_box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
        info_box.set_size_request(430, 210)
        info_box.pack_start(keys_scrolled, True, True, 0)
        info_box.pack_start(info_scrolled, True, True, 0)
        info_scrolled.add(self.process_info_label)
        right_box.add(info_box)
        self.process_select = self.process_treeview.get_selection()
        self.process_select.connect("changed", self.selection_changed)
        self.param_select = self.keys_tree.get_selection()
        self.param_select.connect("changed", self.selection_changed)
        self.app_select = self.applications_treeview.get_selection()
        self.app_select.connect("changed", self.app_selection_changed)
        self.applications_treeview.selected_app = '/(ALL)'
        self.closing = False

        def proc_tree_update():
            if self.closing:
                return False
            self.process_treeview.fill_store(
                self.applications_treeview.selected_app
            )
            proc_adj.set_value(0)
            return True

        def app_tree_update():
            if self.closing:
                return False
            self.applications_treeview.fill_store()
            app_adj.set_value(0)
            return True

        GLib.timeout_add_seconds(1, proc_tree_update)
        GLib.timeout_add_seconds(1, app_tree_update)
Пример #5
0
class MainWindow(Gtk.Window):

    def __init__(self):
        super().__init__(title="Task manager")
        self.connection = None
        self.set_position(Gtk.WindowPosition.CENTER)
        self.set_size_request(1000, 500)
        master_box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
        self.add(master_box)
        hpaned = Gtk.Paned()
        master_box.add(hpaned)
        left_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
        right_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
        app_header = Gtk.Label(label='APPLICATIONS')
        self.proc_header = Gtk.Label(label='PROCESSES')
        left_box.pack_start(app_header, False, True, 0)
        right_box.pack_start(self.proc_header, False, True, 0)
        hpaned.add1(left_box)
        hpaned.add2(right_box)
        applications_tree_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
        self.applications_treeview = ApplicationTree()
        app_adj = Gtk.Adjustment()
        applications_scroll = Gtk.ScrolledWindow(app_adj)
        applications_scroll.set_size_request(400, 500)
        applications_scroll.add_with_viewport(self.applications_treeview)
        left_box.pack_start(applications_tree_box, False, True, 0)
        applications_tree_box.pack_start(applications_scroll, True, True, 0)
        proc_adj = Gtk.Adjustment()
        process_tree_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
        right_box.pack_start(process_tree_box, False, True, 0)
        self.process_scroll = Gtk.ScrolledWindow(proc_adj)
        self.process_scroll.set_size_request(600, 220)
        process_tree_box.pack_start(self.process_scroll, True, True, 0)
        self.process_treeview = ProcessTree()
        self.process_scroll.add_with_viewport(self.process_treeview)
        button_box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
        right_box.pack_end(button_box, False, True, 0)
        close_button = Gtk.Button(label="Close")
        close_button.connect("clicked", self.close_app)
        button_box.pack_start(close_button, True, True, 0)
        # self.freeze_button = FreezeButton()
        # self.freeze_button.connect('clicked', self.freeze)
        # button_box.pack_start(self.freeze_button, True, True, 0)
        self.proc_kill_button = ProcessKillButton()
        self.proc_kill_button.connect("clicked", self.kill_process)
        button_box.pack_start(self.proc_kill_button, True, True, 0)
        self.process_info_label = Gtk.Label()
        self.process_info_label.set_size_request(430, 210)
        self.process_info_label.set_selectable(True)
        self.process_info_label.set_line_wrap(True)
        self.info_header = Gtk.Label(label='DETAILED PROCESS INFO')
        right_box.pack_start(self.info_header, True, True, 0)
        keys_scrolled = Gtk.ScrolledWindow()
        self.keys_tree = InfoTree(1)
        keys_scrolled.add(self.keys_tree)
        info_scrolled = Gtk.ScrolledWindow()
        info_scrolled.set_size_request(430, 210)
        info_box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
        info_box.set_size_request(430, 210)
        info_box.pack_start(keys_scrolled, True, True, 0)
        info_box.pack_start(info_scrolled, True, True, 0)
        info_scrolled.add(self.process_info_label)
        right_box.add(info_box)
        self.process_select = self.process_treeview.get_selection()
        self.process_select.connect("changed", self.selection_changed)
        self.param_select = self.keys_tree.get_selection()
        self.param_select.connect("changed", self.selection_changed)
        self.app_select = self.applications_treeview.get_selection()
        self.app_select.connect("changed", self.app_selection_changed)
        self.applications_treeview.selected_app = '/(ALL)'
        self.closing = False

        def proc_tree_update():
            if self.closing:
                return False
            self.process_treeview.fill_store(
                self.applications_treeview.selected_app
            )
            proc_adj.set_value(0)
            return True

        def app_tree_update():
            if self.closing:
                return False
            self.applications_treeview.fill_store()
            app_adj.set_value(0)
            return True

        GLib.timeout_add_seconds(1, proc_tree_update)
        GLib.timeout_add_seconds(1, app_tree_update)

#    def freeze(self, button):
#        self.process_treeview.frozen = (
#            True if not self.process_treeview.frozen else False
#        )
#        self.applications_treeview.frozen = (
#            True if not self.applications_treeview.frozen else False
#        )
#        button.set_label(
#            label=(
#                'Continue' if self.process_treeview.frozen else 'Freeze')
#        )

    def app_selection_changed(self, selection):
        if self.applications_treeview.updating:
            return
        model, treeiter = selection.get_selected()
        self.applications_treeview.selected_app = model[treeiter][0] + \
            '/' + model[treeiter][1]
        self.proc_header.set_text('PROCESSES ({0})'.format(
            self.applications_treeview.selected_app))
        self.process_treeview.need_to_change_labels = True
        self.process_treeview.fill_store(
            self.applications_treeview.selected_app)
        name = psutil.Process(
            self.process_treeview.selected_pid
        ).as_dict(attrs=['name'])['name']
        self.info_header.set_text(
            'DETAILED PROCESS INFO ({0} {1})'.format(
                self.process_treeview.selected_pid,
                name)
        )
        self.labels_update()
        self.process_treeview.set_cursor(
            0, self.process_treeview.get_column(0)
        )
        self.process_treeview.app_cursor = (
            self.process_treeview.get_cursor()
        )

    def selection_changed(self, selection):
        if self.process_treeview.updating:
            return
        model, treeiter = selection.get_selected()
        if treeiter:
            if type(model[treeiter][0]) == str:
                self.keys_tree.selected_key = model[treeiter][0]
            elif type(model[treeiter][0]) == int:
                self.process_treeview.selected_pid = model[treeiter][0]
                self.info_header.set_text(
                    'DETAILED PROCESS INFO ({0} {1})'.format(
                        self.process_treeview.selected_pid,
                        model[treeiter][1]
                    )
                )
            self.labels_update()

    def labels_update(self):

        def float_to_date(float_arg):
            date = datetime.fromtimestamp(
                float_arg
            ).strftime('%H:%M:%S %Y-%m-%d')
            return date

        dict_info = psutil.Process(
            self.process_treeview.selected_pid).as_dict()
        if self.keys_tree.selected_key == '(ALL)':
            info = ''
            for key in dict_info.keys():
                info = '{0} {1}: {2}\n\n'.format(
                    info,
                    key,
                    dict_info[key]
                )
        else:
            if self.keys_tree.selected_key == 'ppid':
                parent_process = ' (parent process: {0})'.format(
                    psutil.Process(
                        dict_info['ppid']
                    ).name()
                ) if self.process_treeview.selected_pid > 1 else '(None)'
            else:
                parent_process = ''
            if self.keys_tree.selected_key == 'create_time':
                formatted_time = ' ({0})'.format(
                    float_to_date(dict_info['create_time'])
                )
            else:
                formatted_time = ''
            info = '{0}: {1} {2} {3}\n\n'.format(
                self.keys_tree.selected_key,
                dict_info[self.keys_tree.selected_key],
                parent_process, formatted_time
            )
        self.process_info_label.set_text(info[:])

    def kill_process(self, button):
        pid = self.process_treeview.selected_pid
        name = psutil.Process(pid).name()
        try:
            psutil.Process(pid).kill()
        except Exception as e:
            print("Process {0} (PID {1}) can't be killed".format(name, pid))
            print(e)
        else:
            self.process_info_label.set_text(
                'Process {0} {1} killed.'.format(pid, name)
            )
            if self.process_treeview.proc_counter == 1:
                self.applications_treeview.set_cursor(
                    0, self.applications_treeview.get_column(0)
                )
                self.applications_treeview.app_cursor = (
                    self.applications_treeview.get_cursor()
                )
            else:
                self.process_treeview.set_cursor(
                    0, self.process_treeview.get_column(0)
                )
                self.process_treeview.proc_cursor = (
                    self.process_treeview.get_cursor()
                )

    def close_app(self, button):
        psutil.Process(
            self.applications_treeview.app_update_pid
        ).kill()
        psutil.Process(
            self.process_treeview.proc_update_pid
        ).kill()
        self.closing = True
        Gtk.main_quit()
 def __init__(self, drivingEngine, exp):
     self.drivingEngine = drivingEngine
     self.tree = ProcessTree(exp)
Пример #7
0
 def __init__(self, drivingEngine, exp):
     self.drivingEngine = drivingEngine
     self.tree = ProcessTree(exp)