Diff Coverage

            dyn_cp_comm = self._ctx.node_eval[target_node].dyn.comm.cp
        if not self.__is_valid_eval_func(dyn_ep_comm):
            dyn_ep_comm = self._ctx.node_eval[target_node].dyn.comm.ep
        if not self.__is_valid_eval_func(dyn_fsdp_comm):
            if target_node in self._ctx.node_eval:
                dyn_fsdp_comm = self._ctx.node_eval[target_node].dyn.comm.fsdp
            else:
                dyn_fsdp_comm = 0
        comm_cls_obj = cls_obj
        if self.is_regular_layer(target_node):
            comm_cls_obj = EvalLayerComm
        return NodeCommEval(

            ccfg, ctx
        )
        # HSDP inter-node all-reduce
        if getattr(ccfg, "comm_hsdp", 0) > 0:
            d_replicate = ccfg.d // d_shard
            # Extra MTP params
            param_size = EvalMTP.num_params_mtp(ccfg, ctx)
            sharded = param_size / (d_shard * ccfg.cp * ccfg.t)
            mtp_fsdp_comm += (
                ccfg.comm_hsdp
                / d_replicate
                * ccfg.n_mtp * sharded
            )

            target_ccfg.fsdp = False
            if op and isinstance(op, int) and op <= 1:
                target_ccfg.has_op = False
            elif not op:
                target_ccfg.has_op = False

    def __apply_d_shard_strategy(self, target_ccfg, d_shard_kw):
        """Apply the HSDP d_shard value, defaulting from dp/fsdp."""
        if d_shard_kw is not None and isinstance(d_shard_kw, int):

        self.ccfg.d_shard = d_shard if self.ccfg.fsdp else 1
        if self.ccfg.fsdp:
            self.config_fsdp_shard(self.ccfg)
        else:
            self.config_optimizer_shard(self.ccfg)
        self.config_comm_flag(self.ccfg)
        self.__parse_batch()
        self.__init_shard()
        self.__init_bytes()

            self.ccfg.op_weight_shard if self.ccfg.op_weight_shard else (self.ccfg.d * self.ccfg.t)
        )
        self.ccfg.fsdp = self.is_fsdp(self.ccfg)
        if self.ccfg.fsdp:
            self.ccfg.d_shard = self.ccfg.d
            self.config_fsdp_shard(self.ccfg)
        else:
            self.ccfg.d_shard = 1
            self.config_optimizer_shard(self.ccfg)

        cc.os_max_shard = cc.d * cc.t
        cc.op_weight_shard = cc.os_max_shard if cc.has_op else 0
        cc.fsdp = self.is_fsdp(cc)
        if cc.fsdp:
            cc.d_shard = cc.d
            self.config_fsdp_shard(cc)
        else:
            cc.d_shard = 1
            self.config_optimizer_shard(cc)

        if d_shard > 1 and not self.dims_val[FSDP]:
            logger.warning("HSDP d_shard > 1 requires FSDP enabled")
            return False
        if d_shard > 1 and self.dims_val[EP] > 1:
            logger.warning("HSDP and EP cannot coexist")
            return False
        if d_shard > 1 and self.dims_val[OP] > 1:
            logger.warning("HSDP and OP cannot coexist (OP > 1)")
            return False
        return True

    def _validate_hsdp_constraints(self):
        """Validate HSDP-related dimension constraints."""

                        idx_lccfg=param["idx_lccfg"],
                    )
                )
        if param["ccfg"].ttype == PerformanceType.TIME:
            for dim, ov in zip([Dim.DP, Dim.TP, Dim.EP], [0.0, 0.0, 0.0]):
                comm[dim] = estimate_comm_score(
                    param["cfg"],
                    comm[dim],
                    dim,

        if param["ccfg"].ttype == PerformanceType.TIME:
            for dim, ov in zip([Dim.DP, Dim.TP, Dim.EP, Dim.CP, Dim.FSDP], [0.9, 0, 0, 0, 0.5]):
                comm[dim] = estimate_comm_score(
                    param["cfg"],
                    comm[dim],
                    dim,

            comm[Dim.DP] /= 2
            comm[Dim.TP] /= 2
            comm[Dim.EP] /= 2
            comm[Dim.CP] /= 2
            comm[Dim.FSDP] /= 2

        comms[Dim.DP].append(comm[Dim.DP])
        comms[Dim.TP].append(comm[Dim.TP])
        comms[Dim.EP].append(comm[Dim.EP])

        logger.info("DP_COMM = %s", comms[Dim.DP])
        logger.info("MP_COMM = %s", comms[Dim.TP])
        logger.info("EP_COMM = %s", comms[Dim.EP])
        logger.info("CP_COMM = %s", comms[Dim.CP])
        logger.info("FSDP_COMM = %s", comms[Dim.FSDP])
        param["debugger"].info[PerfParts.DP_COMM] = comms[Dim.DP]
        param["debugger"].info[PerfParts.MP_COMM] = comms[Dim.TP]
        param["debugger"].info[PerfParts.EP_COMM] = comms[Dim.EP]
        param["debugger"].info[PerfParts.CP_COMM] = comms[Dim.CP]
        param["debugger"].info[PerfParts.FSDP_COMM] = comms[Dim.FSDP]

    res = []
    for i, c in enumerate(comms[Dim.TP]):
        res += [c + comms[Dim.DP][i] + comms[Dim.EP][i] + comms[Dim.CP][i] + comms[Dim.FSDP][i]]