OCS_TMP/ocs/note.md

# xz_cable_setup_check_tool.py build

```shell
pyinstaller --onefile \
--paths=/home/gyou/NexusBench-baihe-br/nexusbench \
--paths=/home/gyou/NexusBench-baihe-br/nexusbench/log \
--paths=/home/gyou/NexusBench-baihe-br/nexusbench/connection \
--paths=/home/gyou/NexusBench-baihe-br/nexusbench/gpu/biren \
--hidden-import=connection.http_helper \
--runtime-tmpdir=/home/gyou/tmp \
/home/gyou/NexusBench-baihe-br/nexusbench/biren_test.py


# 加了这一行就可以运行了
--runtime-tmpdir=/home/gyou/tmp \

--hidden-import=log.logger \
--hidden-import=connection.ssh_connection_manager \

```


 ./build/whiteriver_exp --host 10.57.216.109 --exp 2 --cmd vcmd --param rev

./vuart -i 10.57.216.109 -e 2 -c vcmd -p ver
./vuart -i 10.57.216.108 -e 4 -c fw-down -p 

./build/whiteriver_exp  -i 10.57.216.108 -e 4 -c fw-down -p 



./build/whiteriver_exp  -i 10.57.216.91 -e 4 -c vcmd -p ver


net use X: \\10.57.216.173\shared /user:root ossdbg1  


PicT1!2@3#4$

 
RCms@Zte3

./build/whiteriver_exp -i 10.57.216.94 -e 4 -c fw-down -p "./whiteriver_exp@1.0.17+2508161844.img"


./build/whiteriver_exp -i 10.57.216.95,10.57.216.96,10.57.216.97,10.57.216.98 



scp /usr/bin/ocs_link_reset root@10.57.216.166


scp -o "BatchMode=no" -o "StrictHostKeyChecking=no" -i pass.txt /usr/bin/ocs_link_reset root@10.57.216.166:/usr/bin/
scp -o "BatchMode=no" -o "StrictHostKeyChecking=no" -i pass.txt /usr/bin/ocs_link_reset root@10.57.216.165:/usr/bin/
scp -o "BatchMode=no" -o "StrictHostKeyChecking=no" -i pass.txt /usr/bin/ocs_link_reset root@10.57.216.187:/usr/bin/
scp -o "BatchMode=no" -o "StrictHostKeyChecking=no" -i pass.txt /usr/bin/ocs_link_reset root@10.57.216.148:/usr/bin/

scp -o "BatchMode=no" -o "StrictHostKeyChecking=no" -i pass.txt /usr/bin/ocs_link_reset root@10.57.216.163:/usr/bin/
scp -o "BatchMode=no" -o "StrictHostKeyChecking=no" -i pass.txt /usr/bin/ocs_link_reset root@10.57.216.139:/usr/bin/
scp -o "BatchMode=no" -o "StrictHostKeyChecking=no" -i pass.txt /usr/bin/ocs_link_reset root@10.57.216.173:/usr/bin/
scp -o "BatchMode=no" -o "StrictHostKeyChecking=no" -i pass.txt /usr/bin/ocs_link_reset root@10.57.216.167:/usr/bin/

scp -o "BatchMode=no" -o "StrictHostKeyChecking=no" -i pass.txt /usr/bin/ocs_link_reset root@10.57.216.134:/usr/bin/
scp -o "BatchMode=no" -o "StrictHostKeyChecking=no" -i pass.txt /usr/bin/ocs_link_reset root@10.57.216.145:/usr/bin/
scp -o "BatchMode=no" -o "StrictHostKeyChecking=no" -i pass.txt /usr/bin/ocs_link_reset root@10.57.216.176:/usr/bin/
scp -o "BatchMode=no" -o "StrictHostKeyChecking=no" -i pass.txt /usr/bin/ocs_link_reset root@10.57.216.180:/usr/bin/

scp -o "BatchMode=no" -o "StrictHostKeyChecking=no" -i pass.txt /usr/bin/ocs_link_reset root@10.57.216.185:/usr/bin/
scp -o "BatchMode=no" -o "StrictHostKeyChecking=no" -i pass.txt /usr/bin/ocs_link_reset root@10.57.216.150:/usr/bin/
scp -o "BatchMode=no" -o "StrictHostKeyChecking=no" -i pass.txt /usr/bin/ocs_link_reset root@10.57.216.168:/usr/bin/
scp -o "BatchMode=no" -o "StrictHostKeyChecking=no" -i pass.txt /usr/bin/ocs_link_reset root@10.57.216.174:/usr/bin/

scp -o "BatchMode=no" -o "StrictHostKeyChecking=no" -i pass.txt /usr/bin/ocs_link_reset root@10.57.216.132:/usr/bin/
scp -o "BatchMode=no" -o "StrictHostKeyChecking=no" -i pass.txt /usr/bin/ocs_link_reset root@10.57.216.189:/usr/bin/
scp -o "BatchMode=no" -o "StrictHostKeyChecking=no" -i pass.txt /usr/bin/ocs_link_reset root@10.57.216.151:/usr/bin/
scp -o "BatchMode=no" -o "StrictHostKeyChecking=no" -i pass.txt /usr/bin/ocs_link_reset root@10.57.216.156:/usr/bin/









    
    def read_tia_stage2_reg(self, exp_id: int, slot_id: int, 
                        lane: int) -> int:
        return self.read_opt_reg(exp_id, slot_id, lane, 'tia_stage2')

    def write_tia_stage2_reg(self, exp_id: int, slot_id: int, 
                        lane: int, wt_value: int) -> bool:
        return self.write_opt_reg(exp_id, slot_id, lane, wt_value, 'tia_stage2')
    
    def write_confirm_reg(self, exp_id: int, slot_id: int) -> bool:
        return self.bmc.SetOpticalModuleRegs(exp_id, slot_id, 0, 0xd0, 0x88, 1, "01")
    
    def read_vpeak_reg(self, exp_id: int, slot_id: int, lane: int) -> int:
        return self.read_opt_reg(exp_id, slot_id, lane, 'vpeak')

    def read_opt_reg(self, exp_id: int, slot_id: int, 
                        lane: int, reg_name: str):  




    def calc_target_vpeak_new(self, exp_id: int, slot_id: int, lane_list: List[int]) -> Dict[int, int]:
        target_vpeaks : Dict[int, int] = {}
        logging.info(f"-------slot {slot_id}")
        
        # 切换成mgc
        logging.info("----------step 1: disable agc")
        self.disable_agc(exp_id, slot_id)

        # 关闭RF
        logging.info("----------step 2: toogle RF off")
        if not self.toogle_rf(exp_id, slot_id, lane_list, "off"):
            logging.error(f"slot {slot_id}: toogle RF off fail")
            return target_vpeaks
        
        # 读取base_line_vpeaks
        logging.info("----------step 3: get base_line_vpeaks, and calculate target vpeaks")
        base_line_vpeaks = self._read_vpeak_all_lanes(exp_id, slot_id, lane_list)
        logging.info(f"base_line_vpeaks: {base_line_vpeaks}")
        self.toogle_rf(exp_id, slot_id, lane_list, "on")

        self._write_mgc_all_lanes(exp_id, slot_id, lane_list, 255)
        time.sleep(0.05) # important
        max_vpeaks = self._read_vpeak_all_lanes(exp_id, slot_id, lane_list)

        for lane, base_vpeak in base_line_vpeaks.items():
            numerator = 16
            vpkdelta = round((max_vpeaks[lane] - base_vpeak) * (numerator / 29))
            logging.info(f'-------numerator:{numerator}')
            target_vpeaks[lane] =  vpkdelta + base_vpeak

        logging.info(f"target_vpeaks: {target_vpeaks}")

        if target_vpeaks:
            self.save_target_vpeaks_to_json(exp_id, slot_id, target_vpeaks)

        # 开启RF
        logging.info("----------step 4: enable RF")
        # time.sleep(5)

        return target_vpeaks


def match_optimal_mgc_new(self, exp_id: int, slot_id: int, lane_list: List[int], target_vpeaks: Dict[int, int]) -> bool:
        matched_results = {} 
        unmatched_lanes = []  

        for lane_id in lane_list:

            is_match = False
            matched_mgc = None
            matched_vpeak = None
        
            reg = self.reg_table.get_register_by_logic_lane('mgc', lane_id)
            if reg is None or reg.valid_range is None:
                logging.error(f'match_optimal_mgc_new error. exp:{exp_id}, slot:{slot_id}, lane: {lane_id}, register name: mgc')
                return False
            
            min_val = reg.valid_range[0]
            max_val = reg.valid_range[1]
            step = reg.step if reg.step is not None else 1

            wt_mgc = int((min_val + max_val) / 2)
            target_vpeak = target_vpeaks[lane_id] # example: 100
            target_vpeak_range = [target_vpeak, target_vpeak + 1] # 99,101
            while True:
                ret = self.reg_tool.write_mgc_reg(exp_id, slot_id, lane_id, wt_mgc)
                if ret == False:
                    logging.error(f'match_optimal_mgc_new error. exp:{exp_id}, slot:{slot_id}, lane: {lane_id}, register name: mgc')
                    return False
                
                time.sleep(0.05)
                ret = self.reg_tool.write_confirm_reg(exp_id, slot_id)
                if ret == False:
                    logging.error(f'match_optimal_mgc_new error. exp:{exp_id}, slot:{slot_id}, lane: {lane_id}, register name: confirm')
                    return False
                
                time.sleep(0.05)
                current_vpeak = self.reg_tool.read_vpeak_reg(exp_id, slot_id, lane_id)

                logging.info(f"exp_id:{exp_id}, slot_id:{slot_id}, lane:{lane_id} ->  set mgc {wt_mgc}, Vpeak value: {current_vpeak}, target: {target_vpeak}")

                diff_vpeak = abs(target_vpeak - current_vpeak)
                diff_vpeak_step = {
                    0: 0,
                    1: 0,
                    2: 1,
                    3: 1,
                    4: 2,
                    5: 3,
                    6: 3,
                    7: 4,
                    8: 5,
                }
                extra_step = diff_vpeak_step.get(diff_vpeak, 5)
                if current_vpeak > target_vpeak_range[1]:
                    wt_mgc -= step + extra_step

                if current_vpeak < target_vpeak_range[0]:
                    wt_mgc += step + extra_step

                if current_vpeak >= target_vpeak_range[0] and current_vpeak <= target_vpeak_range[1]:
                    is_match = True
                    matched_mgc = wt_mgc
                    matched_vpeak = current_vpeak
                    break
            
            if is_match:
                logging.info(f"------------------ Vpeak is matched, target vpeak:{target_vpeak}, current vpeak: {current_vpeak}, current mgc:{wt_mgc} ")
                if str(exp_id) not in matched_results:
                    matched_results[str(exp_id)] = {}
                if str(slot_id) not in matched_results[str(exp_id)]:
                    matched_results[str(exp_id)][str(slot_id)] = {}
                if self.mode not in matched_results[str(exp_id)][str(slot_id)]:
                    matched_results[str(exp_id)][str(slot_id)][self.mode] = {}
                    
                matched_results[str(exp_id)][str(slot_id)][self.mode][str(reg.lane)] = {
                    "mgc": matched_mgc,
                    "target_vpeak": target_vpeaks[lane_id],
                    "actual_vpeak": matched_vpeak
                }
            else:
                unmatched_lanes.append(lane_id)
        
        if matched_results:
            self.save_mgc_results_to_json(exp_id, slot_id, matched_results)
            
        if unmatched_lanes:
            logging.error(f"以下lane未匹配到合适的MGC值: {unmatched_lanes}")
            return False
            
        return True


            remote_slot = self.topo_map.get_remote_slot_by_retimer(eye.rt_index, eye.lane_index, self.route_name)
        local_slot = self.topo_map.get_local_slot_by_retimer(eye.rt_index, eye.lane_index, self.route_name)




        import re
import yaml
from typing import List, Dict, Optional, Tuple, Iterator
from dataclasses import dataclass


@dataclass(frozen=True)
class Side:
    """
    Represents one side of a link (e.g., host side or device side),
    explicitly containing GPU, Retimer, and Slot with their indices and lanes.
    """
    gpu_index: int
    gpu_lane: int
    retimer_index: int
    retimer_lane: int
    slot_index: int
    slot_lane: int

    def __str__(self) -> str:
        return (f"GPU{self.gpu_index}_L{self.gpu_lane} <-> "
                f"RTMR{self.retimer_index}_L{self.retimer_lane} <-> "
                f"SLOT{self.slot_index}_L{self.slot_lane}")


@dataclass(frozen=True)
class TopoLink:
    """
    Represents a full physical link between two sides (A and B).
    Example: Side(GPU0, RTMR21, SLOT0) <-> Side(GPU6, RTMR32, SLOT0)
    """
    side_a: Side
    side_b: Side
    route_name: str

    def __str__(self) -> str:
        return f"{self.side_a}  <->  {self.side_b}"
    
@dataclass
class Route:
    name: str
    links: List[TopoLink]

    def __iter__(self) -> Iterator[TopoLink]:
        return iter(self.links)

    def __len__(self) -> int:
        return len(self.links)


class TopoMappingParser:
    """
    Parses topology YAML file into structured links with explicit Side components.
    Provides utility methods to query relationships between Retimer, Slot, GPU.
    All query methods now support optional filtering by route_name.
    """

    # Regex to match: DEVICE<index>_L<lane>, e.g., GPU0_L0, RTMR21_L7, SLOT5_L3
    _TOKEN_PATTERN = re.compile(r"([A-Z]+)(\d+)_L(\d+)")

    def __init__(self, yaml_file: str):
        self.yaml_file = yaml_file
        self.routes: List[Route] = []
        self._all_links: List[TopoLink] = []  # Flat index for fast lookup

    def parse(self) -> 'TopoMappingParser':
        """Parse YAML and build structured links."""
        with open(self.yaml_file, 'r') as f:
            data = yaml.safe_load(f)

        self.routes.clear()
        self._all_links.clear()

        for item in data:
            if 'route_name' not in item or 'links' not in item:
                continue

            route_name = item['route_name']
            links = []

            for link_str in item['links']:
                try:
                    link = self._parse_link(link_str.strip(), route_name)
                    links.append(link)
                    self._all_links.append(link)
                except Exception as e:
                    raise ValueError(f"Failed to parse link '{link_str}' in route '{route_name}': {e}")

            self.routes.append(Route(route_name, links))

        return self

    def _parse_link(self, link_str: str, route_name: str) -> TopoLink:
        """
        Parse a link string into two structured Sides (A and B).
        Assumes format: GPUx_La <-> RTMRy_Lb <-> SLOTz_Lc <-> ... <-> GPUx_La
        And that both ends have: GPU, RTMR, SLOT in order.
        Middle may have repeated SLOT/RTMR.
        """
        tokens = [t.strip() for t in link_str.split('<->')]
        if len(tokens) < 6:
            raise ValueError(f"Link too short to extract both sides: {link_str}")

        # Parse all nodes
        nodes = [self._parse_token(tok) for tok in tokens]

        # Find split point: assume symmetry, and RTMR is near both ends
        rt_indices = [i for i, (t, _, _) in enumerate(nodes) if t == "RTMR"]
        if len(rt_indices) < 2:
            raise ValueError(f"Link must have at least two retimers: {link_str}")

        mid = len(nodes) // 2

        # Extract Side A (from start to middle RTMR)
        side_a = self._extract_side(nodes[:mid + 1])
        # Extract Side B (from middle to end)
        side_b = self._extract_side(list(reversed(nodes[mid:])))

        return TopoLink(side_a=side_a, side_b=side_b, route_name=route_name)

    def _parse_token(self, token: str) -> Tuple[str, int, int]:
        """
        Parse token like 'GPU0_L0' into (type, index, lane)
        """
        match = self._TOKEN_PATTERN.fullmatch(token)
        if not match:
            raise ValueError(f"Invalid token format: '{token}'")
        dev_type, idx, lane = match.groups()
        return dev_type, int(idx), int(lane)

    def _extract_side(self, nodes: List[Tuple[str, int, int]]) -> Side:
        """
        Extract GPU, RTMR, SLOT from a list of nodes (assumed to be one side).
        Picks the first occurrence of each.
        """
        gpu = retimer = slot = None
        for dev_type, idx, lane in nodes:
            if dev_type == "GPU" and gpu is None:
                gpu = (idx, lane)
            elif dev_type == "RTMR" and retimer is None:
                retimer = (idx, lane)
            elif dev_type == "SLOT" and slot is None:
                slot = (idx, lane)
        if not gpu or not retimer or not slot:
            raise ValueError(f"Missing components in side: GPU={gpu}, RTMR={retimer}, SLOT={slot}")
        return Side(
            gpu_index=gpu[0], gpu_lane=gpu[1],
            retimer_index=retimer[0], retimer_lane=retimer[1],
            slot_index=slot[0], slot_lane=slot[1]
        )
    
    # --------------------------------------------------
    # 🔧 UTILITY METHODS (now support route_name filtering)
    # --------------------------------------------------

    def _filter_links(self, links: List[TopoLink], route_name: Optional[str]) -> List[TopoLink]:
        """Helper to filter links by route_name if provided."""
        if route_name is None:
            return links
        return [link for link in links if link.route_name == route_name]

    def get_links_by_retimer(self, rtmr_idx: int, rtmr_lane: int, route_name: Optional[str] = None) -> List[TopoLink]:
        """Get all links containing the given retimer (index and lane), optionally filtered by route_name."""
        links = [link for link in self._all_links
                if (link.side_a.retimer_index == rtmr_idx and link.side_a.retimer_lane == rtmr_lane)
                or (link.side_b.retimer_index == rtmr_idx and link.side_b.retimer_lane == rtmr_lane)]
        
        return self._filter_links(links, route_name)

    def get_local_side_by_retimer(self, rtmr_idx: int, rtmr_lane: int, route_name: Optional[str] = None) -> Optional[Side]:
        """
        Given a retimer (index, lane), return the local Side (GPU + SLOT on same side),
        optionally filtered by route_name.
        """
        links = self.get_links_by_retimer(rtmr_idx, rtmr_lane, route_name)
        for link in links:
            if link.side_a.retimer_index == rtmr_idx and link.side_a.retimer_lane == rtmr_lane:
                return link.side_a
            if link.side_b.retimer_index == rtmr_idx and link.side_b.retimer_lane == rtmr_lane:
                return link.side_b
        return None

    def get_remote_side_by_retimer(self, rtmr_idx: int, rtmr_lane: int, route_name: Optional[str] = None) -> Optional[Side]:
        """
        Given a retimer (index, lane), return the *remote* Side (the other end),
        optionally filtered by route_name.
        """
        links = self.get_links_by_retimer(rtmr_idx, rtmr_lane, route_name)
        for link in links:
            if link.side_a.retimer_index == rtmr_idx and link.side_a.retimer_lane == rtmr_lane:
                return link.side_b
            if link.side_b.retimer_index == rtmr_idx and link.side_b.retimer_lane == rtmr_lane:
                return link.side_a
        return None

    def get_local_slot_by_retimer(self, rtmr_idx: int, rtmr_lane: int, route_name: Optional[str] = None) -> Optional[Tuple[int, int]]:
        """
        Get (slot_index, slot_lane) on the same side as the given retimer,
        optionally filtered by route_name.
        """
        side = self.get_local_side_by_retimer(rtmr_idx, rtmr_lane, route_name)
        return (side.slot_index, side.slot_lane) if side else None

    def get_remote_slot_by_retimer(self, rtmr_idx: int, rtmr_lane: int, route_name: str) -> Optional[Tuple[int, int]]:
        """
        Get (slot_index, slot_lane) on the opposite side of the given retimer,
        optionally filtered by route_name.
        """
        side = self.get_remote_side_by_retimer(rtmr_idx, rtmr_lane, route_name)
        return (side.slot_index, side.slot_lane) if side else None

    def get_retimer_by_slot(self, slot_idx: int, slot_lane: int, route_name: str) -> Optional[Tuple[int, int, int, int]]:
        """
        Given a slot (index, lane), return:
        (retimer_index, retimer_lane, peer_slot_idx, peer_slot_lane)
        Optionally filtered by route_name.
        """
        links = self._filter_links(self._all_links, route_name)
        for link in links:
            if (link.side_a.slot_index == slot_idx and link.side_a.slot_lane == slot_lane):
                return (
                    link.side_a.retimer_index,
                    link.side_a.retimer_lane,
                    link.side_b.slot_index,
                    link.side_b.slot_lane
                )
            if (link.side_b.slot_index == slot_idx and link.side_b.slot_lane == slot_lane):
                return (
                    link.side_b.retimer_index,
                    link.side_b.retimer_lane,
                    link.side_a.slot_index,
                    link.side_a.slot_lane
                )
        return None

    def get_gpu_by_slot(self, slot_idx: int, slot_lane: int, route_name: Optional[str] = None) -> Optional[Tuple[int, int]]:
        """Get (gpu_index, gpu_lane) connected to the given slot, optionally filtered by route_name."""
        links = self._filter_links(self._all_links, route_name)
        for link in links:
            if link.side_a.slot_index == slot_idx and link.side_a.slot_lane == slot_lane:
                return (link.side_a.gpu_index, link.side_a.gpu_lane)
            if link.side_b.slot_index == slot_idx and link.side_b.slot_lane == slot_lane:
                return (link.side_b.gpu_index, link.side_b.gpu_lane)
        return None

    def find_symmetric_links(self, route_name: Optional[str] = None) -> List[TopoLink]:
        """Find links where both sides are identical (e.g., oneta loops), optionally filtered by route_name."""
        links = self._filter_links(self._all_links, route_name)
        return [
            link for link in links
            if (link.side_a.gpu_index == link.side_b.gpu_index and
                link.side_a.retimer_index == link.side_b.retimer_index and
                link.side_a.slot_index == link.side_b.slot_index and
                link.side_a.gpu_lane == link.side_b.gpu_lane and
                link.side_a.retimer_lane == link.side_b.retimer_lane and
                link.side_a.slot_lane == link.side_b.slot_lane)
        ]


if __name__ == "__main__":
    # 示例用法
    parser = TopoMappingParser("./main_data/topo_mapping.yaml")
    parser.parse()

    # 原始调用（跨所有 route）
    print("All routes - local slot for RTMR21_L0:", parser.get_local_slot_by_retimer(21, 0))
    print("All routes - remote slot for RTMR21_L0:", parser.get_remote_slot_by_retimer(21, 0))

    # 按 route_name 查询
    print("onoc6 - local slot for RTMR21_L0:", parser.get_local_slot_by_retimer(21, 0, route_name="onoc6"))
    print("onoc6 - remote slot for RTMR21_L0:", parser.get_remote_slot_by_retimer(21, 0, route_name="onoc6"))

    print("onoc5 - local slot for RTMR21_L0:", parser.get_local_slot_by_retimer(21, 0, route_name="onoc5"))
    print("onoc5 - remote slot for RTMR21_L0:", parser.get_remote_slot_by_retimer(21, 0, route_name="onoc5"))

    # 其他查询也支持 route_name
    print("oneta - symmetric links count:", len(parser.find_symmetric_links(route_name="oneta")))
    print("onoc6 - GPU connected to SLOT0_L0:", parser.get_gpu_by_slot(0, 0, route_name="onoc6"))
    print("onoc5 - GPU connected to SLOT0_L0:", parser.get_gpu_by_slot(0, 0, route_name="onoc5"))