Diff Coverage

        self.pp = pp
        self.vpp = vpp

    def __str__(self):
        return "PP: " + str(self.pp) + ", VPP: " + str(self.vpp)

    def chunk_stage(self):
        """Product of chunks and stages"""
        return self.pp * self.vpp

def infer_pp_and_vpp(offset):
    """Return a pipeline configuration inferred from an offset"""
    if is_zero_d(offset):
        return Pipeline(1, 1)
    if is_one_d(offset):
        return Pipeline(len(offset), 1)
    if is_two_d(offset):
        return Pipeline(len(offset[0]), len(offset))
    raise TypeError(f"Offset {offset} has a wrong type!")


class BalancingAdapter:
    """Adapt pipeline balancing to a given 'new' pipeline configuration"""

        self.prev_pip = infer_pp_and_vpp(offset)

    def treat_pp_list(self, new_pip, stages):
        """Treat 1D offset or recompute config"""
        current_pp_len = len(stages)
        logger.debug(
            "new pp (%d) = prev pp (%d)? l = %s, len(l) = %d",
            new_pip.pp,
            self.prev_pip.pp,
            str(stages),

            self.prev_pip.pp,
            str(stages),
            len(stages),
        )
        if new_pip.pp == current_pp_len:
            return stages
        new_l = []
        if new_pip.pp > current_pp_len:
            while new_pip.pp % len(stages) != 0:
                stages.insert(len(stages) // 2, 0)
            logger.debug("stages: %s", str(stages))
            factor = new_pip.pp // current_pp_len
            for s in stages:
                rest = s % factor
                for _ in range(factor):
                    if rest > 0:
                        new_l.append(s // factor + 1)
                        rest -= 1
                    else:
                        new_l.append(s // factor)
        if new_pip.pp < current_pp_len:
            for _ in range(current_pp_len % new_pip.pp):
                stages.insert(len(stages) // 2, 0)
            factor = current_pp_len // new_pip.pp
            for i in range(new_pip.pp):
                total_rec_layers = 0
                for j in range(factor):
                    total_rec_layers += stages[i * factor + j]
                new_l.append(total_rec_layers)
        return new_l

    def treat_vpp_list(self, new_pip, ll):
        """Treat 2D offset or recompute config"""
        logger.debug("treat_vpp_list start: ll = %s", str(ll))
        prev_vpp = len(ll)
        if prev_vpp < new_pip.vpp:
            if prev_vpp == 1:
                ll.append([0] * self.prev_pip.pp)
                ll[1][-1] = ll[0][-1]
                ll[0][-1] = 0
                prev_vpp = 2
            for _ in range(new_pip.vpp - prev_vpp):
                ll.insert(prev_vpp // 2, [0] * self.prev_pip.pp)
            logger.debug("B: ll = %s", str(ll))

            prev_layer_per_stage = [
                prev_vpp * (self.layers // self.prev_pip.chunk_stage())
                + sum(stages[p] for stages in make_two_d(self.prev_offset))
                for p in range(self.prev_pip.pp)
            ]
            new_layer_per_stage = [
                new_pip.vpp * (self.layers // self.prev_pip.chunk_stage())
                + sum(stages[p] for stages in ll)
                for p in range(self.prev_pip.pp)
            ]
            logger.debug(
                "prev_layer_per_stage = %s", str(prev_layer_per_stage)
            )
            logger.debug("new_layer_per_stage = %s", str(new_layer_per_stage))
            for s in range(self.prev_pip.pp):
                for v in range(new_pip.vpp):
                    if (
                        prev_layer_per_stage[s] - new_layer_per_stage[s] > 0
                        and ll[v][s] < 1
                    ):
                        ll[v][s] += 1
                        new_layer_per_stage[s] += 1

        elif prev_vpp > new_pip.vpp:
            for _ in range(prev_vpp - new_pip.vpp):
                ll[-2] = [sum(x) for x in zip(ll[-1], ll[-2])]
                del ll[-1]
        logger.debug("C: ll = %s", str(ll))
        new_vpp_list = []
        for stages in ll:
            new_vpp_list.append(self.treat_pp_list(new_pip, stages))
        logger.debug("D: new_vpp_list = %s", str(new_vpp_list))
        return new_vpp_list

    def treat_recompute_list(self, new_pip, recompute):
        """Treat recompute config recursively"""
        if all(isinstance(x, int) for x in recompute):
            if all(isinstance(x, int) for x in recompute):
                if new_pip.vpp == 1:
                    return self.treat_pp_list(new_pip, recompute)
                return self.treat_vpp_list(new_pip, recompute)
        elif all(isinstance(x, int) for stages in recompute for x in stages):
            if new_pip.vpp == 1:
                return self.treat_vpp_list(new_pip, recompute)[0]
            return self.treat_vpp_list(new_pip, recompute)
        return recompute

    def treat_recompute(self, new_pp, new_vpp):
        """Treat recompute config for the new given Pipeline config"""
        new_pip = Pipeline(new_pp, new_vpp)

        if not self.from_config:
            return self.default_recompute(
                new_pip, copy.deepcopy(self.prev_recompute)
            )
        if new_pip == self.prev_pip or isinstance(self.prev_recompute, bool):
            return copy.deepcopy(self.prev_recompute)
        return self.treat_recompute_list(
            new_pip, copy.deepcopy(self.prev_recompute)
        )

    def treat_offset(self, new_pp, new_vpp):

        """Treat offset for the new given Pipeline config"""
        new_pip = Pipeline(new_pp, new_vpp)
        if not self.from_config:
            return self.make_valid(new_pip, self.default_offset(new_pip))
        offset = copy_offset(self.prev_offset)
        if new_pip == self.prev_pip:
            logger.debug("Same pipeline, no offset change")
            return offset
        logger.debug(
            "change offset %s from PP = %d, VPP = %d, to PP = %d, VPP = %d",
            str(offset),
            self.prev_pip.pp,
            self.prev_pip.vpp,

            new_pip.pp,
            new_pip.vpp,
        )

        if is_zero_d(offset):
            offset = []
            for _ in range(new_pip.vpp):
                offset.append([])
                for _ in range(new_pip.pp):
                    offset[-1].append(0)
            return self.make_valid(new_pip, offset)
        if is_one_d(offset):
            if new_pip.vpp == 1:
                return self.make_valid(
                    new_pip, self.treat_pp_list(new_pip, offset)
                )
            return self.make_valid(
                new_pip, self.treat_vpp_list(new_pip, [offset])
            )
        if is_two_d(offset):
            return self.make_valid(
                new_pip, self.treat_vpp_list(new_pip, offset)
            )
        raise TypeError(f"Offset {offset} has a wrong type!")

    def check_offset(self, new_pip, offset):
        """Check offset validity"""
        if is_zero_d(offset):
            return (new_pip.pp == 1) and (new_pip.vpp == 1)
        if is_one_d(offset):
            return (
                len(offset) == new_pip.pp
                and sum(offset) == self.layers % new_pip.pp

            return (
                len(offset) == new_pip.pp
                and sum(offset) == self.layers % new_pip.pp
            )
        if is_two_d(offset):
            return (
                len(offset) == new_pip.vpp
                and all(len(stages) == new_pip.pp for stages in offset)
                and sum(sum(stages) for stages in offset)
                == self.layers % (new_pip.chunk_stage())

                and all(len(stages) == new_pip.pp for stages in offset)
                and sum(sum(stages) for stages in offset)
                == self.layers % (new_pip.chunk_stage())
            )
        return False

    def offset_checker(self, new_pp, new_vpp, offset):
        """Log an error message if offset is invalid"""
        new_pip = Pipeline(new_pp, new_vpp)

    def offset_checker(self, new_pp, new_vpp, offset):
        """Log an error message if offset is invalid"""
        new_pip = Pipeline(new_pp, new_vpp)
        if not self.check_offset(new_pip, offset):
            logger.error(
                "offset %s is wrong!! pp = %d, vpp = %d, L = %d",
                str(offset),
                new_pip.pp,
                new_pip.vpp,

                new_pip.pp,
                new_pip.vpp,
                self.layers,
            )
            return False
        return True

    def make_valid(self, new_pip, offset):
        """Transform an invalid offset into a valid one"""

        delta = self.layers % (new_pip.chunk_stage()) - sum(flat)
        logger.debug("delta = %s", str(delta))
        if delta < 0:
            for _ in range(-delta):
                top = max(flat)
                for i, _ in enumerate(flat):
                    if flat[i] == top:
                        flat[i] = flat[i] - 1
                        break
        elif delta > 0:
            for _ in range(delta):
                bot = min(flat)
                for i, _ in enumerate(flat):

        logger.debug("new flat offset = %s", str(flat))
        if new_pip.vpp == 1:
            return flat

        for v in range(new_pip.vpp):
            for s in range(new_pip.pp):
                offset[v][s] = flat[v * new_pip.pp + s]
        return offset

    def default_offset(self, new_pip):
        """Construct default offset"""
        rest = self.layers % (new_pip.chunk_stage())

        for v in range(new_pip.vpp):
            offset.insert(0, [])
            for s in range(new_pip.pp):
                if rest > 0 and v > 0 and s > 0:
                    offset[0].insert(0, 1)
                    rest -= 1
                else:
                    offset[0].insert(0, 0)
        if offset[0][0] == 1:
            offset[0][0] = 0
            offset[-1][-1] = 1
        return offset

    def default_recompute(self, _, recompute_cfg):
        """Construct Default recompute config when not taken from config"""

def copy_offset(offset):
    """Copy an offset"""
    if is_zero_d(offset):
        return offset
    return copy.deepcopy(offset)


def is_zero_d(offset):
    """Check if offset is an int"""

def make_one_d(offset):
    """Transform offset is an int list"""
    if is_zero_d(offset):
        return [0]
    if is_one_d(offset):
        return offset
    if is_two_d(offset):
        return [x for stages in offset for x in stages]
    raise TypeError(f"Offset {offset} has a wrong type!")


def make_two_d(offset):
    """Transform offset is an int list list"""
    if is_zero_d(offset):
        return [[0]]
    if is_one_d(offset):
        return [offset]
    if is_two_d(offset):
        return offset
    raise TypeError(f"Offset {offset} has a wrong type!")

    def __init__(self, number, device):
        self.number = number
        if isinstance(device, int):
            if device == 2:
                self.device = Device_A2
            elif device == 3:
                self.device = Device_A3
            else:
                raise ValueError(f"Ascend A{device} unknown")

            else:
                raise ValueError(f"Ascend A{device} unknown")
        elif isinstance(device, str):
            if device not in device_map:
                raise ValueError(
                    f"Device {device} is not supported. "
                    f"Supported devices: {list(device_map.keys())}"
                )
            self.device = device_map[device]

    TOTAL = auto()
    MEMORY = auto()

    def __str__(self):
        return self.name

    def short_name(self):
        """Returns short component name"""
        name = "Perf"
        if self == self.FW_COMPUTE:
            name = "FW"
        elif self == self.BW_COMPUTE:
            name = "BW"
        elif self == self.RECOMPUTE:
            name = "Rec"
        elif self == self.DP_COMM:
            name = "DP"
        elif self == self.MP_COMM:
            name = "MP"
        elif self == self.EP_COMM:
            name = "EP"
        elif self == self.CP_COMM:
            name = "CP"
        elif self == self.PP_COMM:
            name = "P2P"
        elif self == self.BUBBLE:
            name = "BBL"
        elif self == self.MEMORY:
            name = "MEM"
        return name


class RealParts(Enum):
    """decomposition of performance"""

    IDLE = auto()
    TOTAL = auto()

    def __str__(self):
        return self.name.lower()


class MemParts(Enum):
    """decomposition of memory"""

    TOTAL = auto()

    def __str__(self):
        return self.name


class Debug:
    """Debugging tools"""

        info_type,
        enable=True,
        output_file="debug.csv",
    ):
        self.enable = enable
        if self.enable:
            self.parallel_dimensions = parallel_dimensions
            self.info = {p: 0 for p in info_type}
            self.output_file = (
                os.path.dirname(os.path.abspath(__file__))
                + "/output/"
                + output_file
            )

            )

    def is_enabled(self):
        """Check whether debugging is enabled"""
        return self.enable

    def column_titles(self):
        """Parameters to debug"""
        titles = self.parallel_dimensions.keys() + list(self.info.keys())
        titles = [str(t) for t in titles]
        return ",".join(titles) + "\n"

    def values(self):
        """values debugged"""
        str_dims = [str(v) for v in self.parallel_dimensions.values()]
        str_score = [str(int(v)) for v in self.info.values()]
        return ",".join(str_dims + str_score) + "\n"

    def write(self):
        """Parameters to debug"""
        if self.enable:
            os.makedirs(os.path.dirname(self.output_file), exist_ok=True)
            is_new = not os.path.exists(self.output_file)
            logger.info("debug written")
            with open(self.output_file, "a", encoding="utf-8") as outfile:
                if is_new:
                    outfile.write(self.column_titles())
                outfile.write(self.values())


def pastel(color, l_delta=0.0, lbl=None, sat=None):
    "Pastel (lighter) color of the input"
    if color == "white":
        return (1.0, 1.0, 1.0)
    if color == "black":
        return (0.5, 0.5, 0.5)
    try:
        color = mc.cnames[color]
    except KeyError:
        pass
    color_hls = colorsys.rgb_to_hls(*mc.to_rgb(color))
    lgt = 0.7
    if lbl is not None:
        lgt = lbl
    lgt = lgt + l_delta

    if sat is None:
        sat = 0.6
    return colorsys.hls_to_rgb(color_hls[0], lgt, sat)


def near_white(color, ratio):
    "Very light color of the input for background"
    rgb = mc.to_rgb(color)
    if rgb is None:
        return "white"
    (red, green, blue) = rgb
    red += (1 - red) * ratio
    green += (1 - green) * ratio
    blue += (1 - blue) * ratio
    return (red, green, blue)


def dim_color(dim, default="black"):
    """Color of parallel dimensions for plot"""
    color = {
        Dim.DP: "orange",
        Dim.OP: "orange",
        Dim.TP: "red",
        Dim.EP: "blue",

        Dim.PP: "green",
        Dim.VPP: "green",
        Dim.MBN: "green",
    }
    try:
        dim = Dim.get_dim(dim)
        if dim in color:
            return color[dim]
        return default
    except ValueError:
        return default


def gen_colors(categories):
    """Color of each time component"""
    compute_color = "purple"
    idle_color = "grey"
    col_d = {
        str(PerfParts.FW_COMPUTE): pastel(compute_color, -0.2),
        str(PerfParts.BW_COMPUTE): pastel(compute_color, -0.1),
        str(PerfParts.RECOMPUTE): pastel(compute_color),
        str(PerfParts.DP_COMM): pastel(dim_color(Dim.DP)),

        str(PerfParts.BUBBLE): pastel(dim_color(Dim.PP), -0.15),
        "IDLE": idle_color,
        "COMPUTATION": pastel(compute_color, -0.2),
    }
    return [col_d[cat] for cat in categories]


def set_twin_handles(ax1, data_frame, dbg_cols):
    """Set legend for estimation and real"""
    handle1, label1 = ax1.get_legend_handles_labels()
    ax2 = plt.twinx()
    data_frame[dbg_cols].plot.bar(
        stacked=True,
        sharex=True,
        ax=ax2,
        position=0,

        width=0.4,
        rot=0,
    )

    handle2, label2 = ax2.get_legend_handles_labels()  # type: ignore
    for handle in handle2:
        if handle not in handle1:
            handle1.append(handle)
    for lbl in label2:
        if lbl not in label1:
            label1.append(lbl)
    handles = handle1
    labels = label1
    plt.legend(handles, labels, loc="upper left", bbox_to_anchor=(1, 1))
    leg = ax2.get_legend()
    pp_color = gen_colors(["PP_COMM"])[0]
    leg.legend_handles[-1].set_facecolor(pp_color)  # type: ignore


class Plot:
    """plot ND top configs"""

    dbg_cols: list[str]
    top: int

    def __init__(self, title, rows, debug_parts, top=None):
        self.title = title
        self.top = top if top is not None else 20
        self.row_title = rows + ["MEM"]
        self.dbg_cols = list(map(str, debug_parts))
        self.col_title = []
        self.cell_text = []
        self.data = []

    def make_table(self):
        """Make table below plot with each parallelism degree"""
        self.cell_text = list(map(list, zip(*self.cell_text)))  # transpose
        max_rows = list(map(max, map(partial(map, float), self.cell_text)))
        the_table = plt.table(
            cellText=self.cell_text,
            rowLabels=self.row_title,
            colLabels=self.col_title,
            cellLoc="center",

            colLabels=self.col_title,
            cellLoc="center",
            loc="bottom",
        )
        row_colors = list(map(dim_color, self.row_title))
        for row in range(len(self.row_title)):
            cell = the_table[row + 1, -1]
            cell.set_edgecolor("none")
            cell.get_text().set_color(row_colors[row])
            cell.set_text_props(fontproperties=FontProperties(weight="bold"))
            for col in range(len(self.cell_text[0])):
                cell = the_table[row + 1, col]
                value = float(str(cell.get_text().get_text()))
                try:
                    ratio = 1 - (value / max_rows[row])
                except ZeroDivisionError:
                    ratio = 0
                logger.debug(
                    "tmax = %s, ratio = %f, col=%s, newcolor=%s",
                    str(max_rows[row]),
                    ratio,
                    str(mc.to_rgb(row_colors[row])),

                    ratio,
                    str(mc.to_rgb(row_colors[row])),
                    str(near_white(row_colors[row], ratio)),
                )
                cell.set_facecolor(near_white(pastel(row_colors[row]), ratio))
                cell.set_edgecolor("none")

        for col in range(len(self.cell_text[0])):
            the_table[0, col].set_edgecolor("none")

        the_table.scale(xscale=1, yscale=1.2)  # +len(rows)/5)

    def close(self, output_path, filename):
        """Plot closing statements"""
        plt.gca().set_xticklabels([])
        plt.gca().set_yticklabels([])
        plt.xlim([-0.5, len(self.data) - 0.5])
        if self.title is not None:
            plt.title(self.title)
        plt.subplots_adjust(left=0.1, bottom=0.047 * (2 + len(self.row_title)))
        plotfile = os.path.join(output_path, filename + ".pdf")
        plt.savefig(plotfile, bbox_inches="tight")
        plt.clf()

    def parse_data(
        self,
        configs_estimated,

        configs_estimated,
        **kwargs,
    ):
        """Parse test data for plot"""
        real_data = kwargs.get("real_data", None)
        plot_idle = kwargs.get("plot_idle", False)
        min_e = configs_estimated[0][2]
        i = 0
        for cfg_e in configs_estimated:
            self.cell_text.append(cfg_e[0].values() + [cfg_e[1]])
            self.col_title.append("")
            try:
                self.data.append(
                    tuple([cfg_e[0], cfg_e[2], cfg_e[3]] + cfg_e[4])
                )
                if real_data is not None:
                    waits = cfg_e[5]
                    logger.info(waits)
                    wait_list = [
                        waits["comp"],
                        waits["dp_wait"],
                        waits["mp_wait"],
                        waits["ep_wait"],

                        waits["mp_wait"],
                        waits["ep_wait"],
                        waits["BUBBLE"],
                    ]
                    if plot_idle:
                        wait_list.append(waits["IDLE"])
                    real_data.append(tuple(wait_list))
            except IndexError:
                score = cfg_e[2]
                if i >= self.top or (min_e is not None and score > min_e * 20):
                    self.cell_text.pop()
                    break
                self.data.append(tuple([cfg_e[0], score] + cfg_e[3]))
                i += 1


def plot_nd(
    configs_estimated, output_path, debug_parts, title=None, max_num=None

def plot_nd(
    configs_estimated, output_path, debug_parts, title=None, max_num=None
):
    """Plot estimation"""
    plot = Plot(
        title, configs_estimated[0][0].keys(), debug_parts, top=max_num
    )
    plot.parse_data(configs_estimated)

    data_frame = pd.DataFrame(
        plot.data, columns=(["config", "estim"] + plot.dbg_cols)
    )
    axis = data_frame[plot.dbg_cols].plot.bar(
        stacked=True, color=gen_colors(plot.dbg_cols), width=0.4, rot=0
    )
    axis.set_ylim(ymin=1)
    axis.legend(loc="upper left", bbox_to_anchor=(1, 1))

    plot.make_table()
    plot.close(output_path, "results")


def plot_vs_real(
    configs_estimated, csv_f, output_path, debug_parts, title=None

def plot_vs_real(
    configs_estimated, csv_f, output_path, debug_parts, title=None
):
    """Plot estimation vs real global time"""
    plot = Plot(title, configs_estimated[0][0].keys(), debug_parts)
    plot.parse_data(configs_estimated)

    data_frame = pd.DataFrame(
        plot.data, columns=(["config", "Real", "estim"] + plot.dbg_cols)
    )
    ax1 = data_frame["Real"].plot.bar(
        position=1.1, width=0.4, secondary_y="real", color="grey", rot=0
    )

    set_twin_handles(ax1, data_frame, plot.dbg_cols)
    plot.make_table()
    plot.close(output_path, Path(os.path.basename(csv_f)).stem)


def plot_vs_real_comm_classified(
    configs_estimated,

    debug_parts,
    **kwargs,
):
    """Plot estimation vs real detailed time"""
    plot_idle = kwargs.get("plot_idle", False)
    title = kwargs.get("title", None)
    real_data = []

    plot = Plot(title, configs_estimated[0][0].keys(), debug_parts)
    plot.parse_data(
        configs_estimated,
        real_data=real_data,
        plot_idle=plot_idle,
    )

        real_data=real_data,
        plot_idle=plot_idle,
    )

    data_frame = pd.DataFrame(
        plot.data, columns=(["config", "real", "estim"] + plot.dbg_cols)
    )
    real_cols = [
        "COMPUTATION",
        "DP_COMM",
        "MP_COMM",
        "EP_COMM",

        "MP_COMM",
        "EP_COMM",
        "BUBBLE",
    ]
    if plot_idle:
        real_cols.append("IDLE")
    real_df = pd.DataFrame(real_data, columns=real_cols)

    ax1 = real_df[real_cols].plot.bar(
        stacked=True,
        sharex=True,
        position=1,
        secondary_y="real",

        rot=0,
        legend=False,
    )

    set_twin_handles(ax1, data_frame, plot.dbg_cols)
    plot.make_table()
    plot.close(
        output_path,
        Path(os.path.basename(csv_f)).stem,
    )

def correlation_topk(configs_estimated, csv_f):
    """Computes correlation & top-k between real & estimation"""
    times = []
    estims = []
    for _, _, time, score, _ in configs_estimated:
        times.append(time)
        estims.append(score)
    correl = pearsonr(times, estims).statistic  # type: ignore
    if isnan(correl):
        logger.critical(
            "An input array is constant: %s or %s", str(times), str(estims)
        )
    topk = 0
    for i, score in enumerate(estims):
        if not score == min(estims[i:]):
            break
        topk += 1
    if topk == 0:
        for i, score in enumerate(estims):
            if score == min(estims[i:]):
                break
            topk -= 1

    logger.info("Correlation for file %s is: %.3f", csv_f, correl * 100)
    return correl, topk


def get_real_data(csv_f):
    """Read execution time of different configurations on a given csv file"""
    configs = []
    row_num = 0
    with open(csv_f, newline="", encoding="utf-8") as csv_file:
        rows = csv.DictReader(csv_file)
        for row in rows:
            row_num += 1
            logger.info(row)
            real_time = float(row.pop("time"))
            config = []
            for dim_str, value in row.items():
                try:
                    dim = Dim.get_dim(dim_str)
                    logger.debug("%s : %s", str(dim), str(dim.from_str(value)))
                    config.append((dim, dim.from_str(value)))
                except ValueError:
                    pass
            configs.append((Dim.Dimensions(config), real_time))
    return configs, row_num


def get_diff_dims(csv_f):
    """Read execution time of different configurations on a given csv file"""
    dims = []
    data_frame = pd.read_csv(csv_f)
    for dim_str, degrees in data_frame.items():
        try:
            dim = Dim.get_dim(dim_str)
            diff_values = len(set(degrees))
            if diff_values > 1:
                dims.append(dim)
        except ValueError:
            pass
    return dims


def get_comm_classified_data(csv_f, plot_idle=False):
    """Read time components of different configurations on a given csv file"""
    configs = []
    with open(csv_f, newline="", encoding="utf-8") as csv_file:
        rows = csv.DictReader(csv_file)
        for row in rows:
            logger.info(row)
            time = float(row.pop("time"))
            config = []
            comm_wait_time_classified = {}
            total_wait = 0

            for component, value_str in row.items():
                if "wait" in component:
                    value_float = float(value_str)
                    logger.info(
                        "Comm_wait = %s, v = %f", component, value_float
                    )
                    comm_wait_time_classified[component] = value_float
                    total_wait += value_float
                elif "comp" in component:
                    value_float = float(value_str)
                    logger.info("Computation = %f", value_float)
                    comm_wait_time_classified["comp"] = value_float
                    total_wait += value_float
                else:
                    logger.info("d = %s, v = %s", component, value_str)
                    dim = Dim.get_dim(component)
                    config.append((dim, dim.from_str(value_str)))
            comm_wait_time_classified["BUBBLE"] = comm_wait_time_classified[
                str(RealParts.PP_WAIT)
            ]
            if plot_idle:
                comm_wait_time_classified["IDLE"] = time - total_wait
                logger.info(
                    "idle = total time - total waits = %.3f - %.3f",
                    time,
                    total_wait,
                )
            configs.append(
                (Dim.Dimensions(config), time, comm_wait_time_classified)
            )
    return configs


def estimation_in_real_parts(
    estimations_in_real_components, estimations, score

    estimations_in_real_components, estimations, score
):
    """Transform the estimation components into
    the RealParts components for comparison with real time"""
    estimations_in_real_components[RealParts.TOTAL].append(score)
    estimations_in_real_components[RealParts.COMP].append(
        estimations[PerfParts.FW_COMPUTE.value - 1]
        + estimations[PerfParts.BW_COMPUTE.value - 1]
        + estimations[PerfParts.RECOMPUTE.value - 1]
    )
    estimations_in_real_components[RealParts.DP_WAIT].append(
        estimations[PerfParts.DP_COMM.value - 1]
    )
    estimations_in_real_components[RealParts.MP_WAIT].append(
        estimations[PerfParts.MP_COMM.value - 1]
    )
    estimations_in_real_components[RealParts.CP_WAIT].append(
        estimations[PerfParts.CP_COMM.value - 1]
    )
    estimations_in_real_components[RealParts.EP_WAIT].append(
        estimations[PerfParts.EP_COMM.value - 1]
    )
    estimations_in_real_components[RealParts.PP_WAIT].append(
        estimations[PerfParts.BUBBLE.value - 1]
        + estimations[PerfParts.PP_COMM.value - 1]
    )
    return estimations_in_real_components


def real_in_parts(parts, real, time):
    """Transform the real time components into

def real_in_parts(parts, real, time):
    """Transform the real time components into
    the RealParts components for comparison with estimation"""
    parts[RealParts.TOTAL].append(time)
    for part in RealParts:
        if part not in {RealParts.TOTAL, RealParts.IDLE}:
            if str(part) in real.keys():
                parts[part].append(real[str(part)])
            else:
                logger.warning(
                    "part = %s not in real keys = %s", part, real.keys()
                )
                parts[part].append(0)

    op = "op_wait"
    if op in real.keys():
        parts[RealParts.DP_WAIT][-1] += real["op_wait"]

    sp = "sp_wait"
    if sp in real.keys():
        parts[RealParts.MP_WAIT][-1] += real["sp_wait"]

    return parts


def correlation_with_classified_comms(configs_estimated):
    """Computes correlation and distance

def correlation_with_classified_comms(configs_estimated):
    """Computes correlation and distance
    between components time & estimation"""
    score_classified = {}
    time_classified = {}
    distances = {}

    for wait in RealParts:
        if wait not in {RealParts.IDLE}:
            score_classified[wait] = []
            time_classified[wait] = []
            distances[wait] = []

    topk = 0
    still_top_k = True

    for i, (_, _, time, score, values, real_values) in enumerate(
        configs_estimated
    ):
        if (
            still_top_k
            and score == (min(configs_estimated[i:], key=lambda t: t[3]))[3]
        ):
            topk += 1
        else:
            still_top_k = False

        score_classified = estimation_in_real_parts(
            score_classified, values, score
        )

        time_classified = real_in_parts(time_classified, real_values, time)

        square_distances_sum = 0
        for wait in RealParts:
            if wait not in {RealParts.TOTAL, RealParts.IDLE}:
                distance = (
                    time_classified[wait][-1]
                    / time_classified[RealParts.TOTAL][-1]
                    - score_classified[wait][-1]
                    / score_classified[RealParts.TOTAL][-1]