def cluster_pipes()

in design_utils/components/hardware.py [0:0]

• 59 lines of code
• 34 McCabe index (conditional complexity)

    def cluster_pipes(self):
        self.pipe_clusters = []
        for block in self.blocks:
            block.reset_clusters()

        def traffic_overlaps(blck_pipe, neigh_pipe):
            blck_pipe_traffic = blck_pipe.get_traffic_names()
            neigh_pipe_traffic = neigh_pipe.get_traffic_names()
            traffic_non_overlap = list(set(blck_pipe_traffic) - set(neigh_pipe_traffic))
            return  len(traffic_non_overlap) < len(blck_pipe_traffic)

        if (len(self.pipes) == 0):
            print("something is wrong")

        assert(len(self.pipes) > 0),  "you need to assign pipes first"
        pipe_cluster_dict = {}

        # iterate through blocks and neighbours to generate clusters
        for block in self.blocks:
            pipe_cluster_dict[block] = {}
            for neigh in block.get_neighs():
                if neigh.type == "pe": continue
                for dir in self.get_pipe_dir(block):
                    if dir not in pipe_cluster_dict[block]: pipe_cluster_dict[block][dir] = {}

                    # get the pipes
                    block_pipes = block.get_pipes(dir)
                    neigh_pipes = neigh.get_pipes(dir)

                    if block_pipes == [] and block.type == "pe":
                        pipe_cluster_dict[block][dir] = {}
                        for neigh_pipe in neigh_pipes:
                            if neigh_pipe.master == block and neigh_pipe.dir == dir:
                                pipe_cluster_dict[block][dir][neigh_pipe] = []
                    elif block.type == "mem":
                        pipe_cluster_dict[block][dir] = {}
                        pipe_cluster_dict[block][dir][None] = block_pipes
                    elif block.type == "ic":
                        if dir not in pipe_cluster_dict[block]:
                            pipe_cluster_dict[block][dir] = {}
                        for blck_pipe in block_pipes:
                            for neigh_pipe in neigh_pipes:
                                if not blck_pipe.slave == neigh_pipe.master:
                                    continue
                                if not(blck_pipe.dir == neigh_pipe.dir):
                                    continue
                                if traffic_overlaps(blck_pipe, neigh_pipe):
                                    if neigh_pipe not in pipe_cluster_dict[block][dir].keys():
                                        pipe_cluster_dict[block][dir][neigh_pipe] = []
                                    if blck_pipe not in pipe_cluster_dict[block][dir][neigh_pipe]:
                                        pipe_cluster_dict[block][dir][neigh_pipe].append(blck_pipe)

        # now generates the clusters
        for block, dir_outgoing_incoming_pipes in pipe_cluster_dict.items():
            for dir, outgoing_pipe_incoming_pipes in dir_outgoing_incoming_pipes.items():
                for outgoing_pipe, incoming_pipes in outgoing_pipe_incoming_pipes.items():
                    pipe_cluster_ = PipeCluster(block, dir, outgoing_pipe, incoming_pipes, self.last_cluster_assigned_number)
                    if outgoing_pipe:  # for pe and ic
                        if outgoing_pipe.master.type == "pe":  # only push once
                            pipe_cluster_.change_to_dummy(outgoing_pipe.master.get_tasks_of_block())
                            if len(outgoing_pipe.master.get_pipe_clusters()) == 0:
                                outgoing_pipe.master.set_pipe_cluster(pipe_cluster_)
                        else:
                            outgoing_pipe.master.set_pipe_cluster(pipe_cluster_)
                    elif incoming_pipes: # for mem
                        incoming_pipes[0].slave.set_pipe_cluster(pipe_cluster_)
                    self.last_cluster_assigned_number += 1
                    self.pipe_clusters.append(pipe_cluster_)

        pass