Yumin Choi

노드 하나를 선택하면 그래프 전체가 다시 그려지던 문제

수천 개 노드를 가진 모델 에디터에서 노드 하나를 선택할 때마다 모든 Node와 Edge가 리렌더되던 문제를, 리듀서 구독 범위를 줄이고 Node에 내려주는 prop을 원시값으로 좁혀 해결한 기록.

문제 상황

딥러닝 모델의 연산 그래프를 DAG로 그려 주는 모델 에디터가 있었다. 모델 하나가 수천 개의 노드와 그만큼의 엣지로 이루어지는 경우가 흔했다.

이 에디터에서 노드 하나를 클릭해 선택하거나, 사이드바에서 레이어 설정을 바꾸면 그래프에 있는 모든 Node 컴포넌트와 Edge 컴포넌트가 다시 렌더됐다. 바뀐 것은 노드 한 개의 선택 상태인데, 화면 전체가 다시 그려지니 선택과 호버 반응이 눈에 띄게 느렸다.

Node와 Edge 안에 console.log("node"), console.log("edge")를 찍어 보니 클릭 한 번에 노드·엣지 수만큼 로그가 쏟아졌다.

문제가 재현된 모델은 노드가 4,381개였다.

변경 전 코드로 다시 재현해 보면, 이 모델에서 선택 노드를 바꾸는 클릭 한 번에 Node 컴포넌트 4,381개가 전부 다시 렌더되고, 메인 스레드가 한 번에 약 580~810ms 동안 묶였다(개발 빌드, React 18 기준).

제보로 알게 된 문제가 아니었다. 직접 에디터를 쓰다가 노드를 클릭할 때마다 화면이 멈추는 것을 느꼈고, 이 규모의 모델에서는 사실상 사용이 불가능하다고 판단했다.

기존 구조

에디터 캔버스 컴포넌트(FlowChart/index.js) 한 파일이 거의 모든 일을 맡고 있었다.

첫째, Redux 구독이 리듀서 단위였다.

const modelReducer = useSelector((state) => state.ModelReducer);
const searchedNode = modelReducer.searchedNode[tab];
const latencyFlag = modelReducer.editorInfo[tab]?.latencyFlag;
// ...
useEffect(() => {
    if (modelReducer.editorInfo[tab].deviceName) {
        // ...
    }
}, [modelReducer.editorInfo[tab].deviceName]);

둘째, Node와 Edge를 JSX 안에서 nodes.map / edges.map으로 직접 렌더하면서, 선택 상태와 관련된 객체와 setter를 그대로 내려줬다.

{nodes.map((node, index) => (
    <Node
        key={`node-${index}`}
        data={node}
        open={open}
        setOpen={setOpen}
        setSelectedNode={setSelectedNode}
        selectedNode={selectedNode}
        settingData={settingData}
        viewer={viewer}
        tab={tab}
    />
))}
// ...
{edges.map((edge, index) => (
    <Edge
        key={`edge-${index}`}
        data={edge}
        graph={graph}
        nodes={nodes}
        selectedData={selectedData}
        settingData={settingData}
        tab={tab}
    />
))}

Node는 selectedNode.id === data.id로 자기 선택 여부를 계산했고, Edge는 selectedData.find((d) => d.id === data.target)로 자기 대상 노드가 선택됐는지 계산했다.

셋째, 드래그 선택 라이브러리(react-selecto) 설정과 콜백, 컨텍스트 메뉴, 줌·스크롤 핸들러가 모두 같은 파일에 있었다.

문제 원인

  • 리듀서 전체 구독. state.ModelReducer를 통째로 구독하면 그 안의 어떤 슬라이스가 바뀌어도 새 참조가 내려와 캔버스 컴포넌트가 리렌더된다. 검색, 액션 플래그, 브레이크다운 등 그래프 렌더와 무관한 상태 변화까지 전부 리렌더 원인이 됐다.
  • memo가 걸러내지 못하는 prop. Node와 Edge는 memo로 감싸져 있었지만, 부모가 리렌더될 때마다 selectedNode 객체, selectedData 배열, setOpen 같은 콜백이 새 참조로 내려갔다. 얕은 비교는 매번 실패했다.
  • 선택 판정이 자식 안에 있음. 선택이 바뀌면 selectedNode, selectedData가 바뀌고, 그 값을 받는 모든 Node와 Edge가 다시 판정을 수행했다. 실제로 표시가 바뀌는 것은 한두 개인데 비교 비용은 전체에 걸렸다.

고려한 해결 방법

처음 시도한 방법은 렌더 단위를 컴포넌트로 쪼개 memo 경계를 만드는 것이었다. NodeRenderer, EdgeRenderer를 만들고, 다시 이 둘을 감싸는 GraphRenderer를 두어 캔버스 컴포넌트에서 노드·엣지 렌더를 분리했다.

// GraphRenderer.js
const GraphRenderer = ({ tab, nodes, edges, graph, selectedNode, selectedData, /* ... */ }) => {
    const model = useSelector((state) => state.ModelReducer.editorInfo[tab].model);
    // ...
    return (
        <div id={`flow-canvas-div-${tab}`}>
            {nodes.length > 0 && <NodeRenderer nodes={nodes} selectedNode={selectedNode} /* ... */ />}
            {nodeRef.current && edges.length > 0 && <EdgeRenderer edges={edges} selectedData={selectedData} /* ... */ />}
        </div>
    );
};
export default memo(GraphRenderer);

이 구조는 약 6주 뒤에 되돌렸다. GraphRenderer를 제거하고 노드·엣지 렌더를 다시 캔버스 컴포넌트 안으로 인라인했다. 이때 휠 핸들러에 걸어 두었던 lodash throttle도 함께 걷어냈다.

되돌린 이유는 단순했다. Renderer로 감싸는 것만으로는 성능 차이가 없었다. 리렌더 범위를 줄인 것은 뒤에 설명할 prop 좁히기와 구독 범위 축소였고, Renderer 래퍼는 그 위에 얹힌 껍데기에 가까웠다. 그래서 파일과 prop 전달 단계만 늘리는 구조를 걷어냈다.

선택한 방법

Renderer 분리는 되돌렸지만, 그 과정에서 함께 넣은 변경은 남았다. 결과적으로 효과가 있었던 것은 "컴포넌트 경계를 하나 더 두는 것"이 아니라 다음 두 가지였다.

  1. prop을 원시값으로 좁힌다. Node에는 selectedNode 객체 대신 부모가 계산한 isSelected boolean만 내려준다. Edge도 selectedData 배열 대신 isSelected boolean을 받는다. 선택 판정을 부모의 map 안으로 올리고, 자식은 결과만 받는다.
  2. 구독 범위를 필요한 슬라이스로 줄인다. 리듀서 전체 구독을 없애고 editorInfo[tab], settingInfo, actionInfo, nodesBreakdown, selectedNodes처럼 실제로 쓰는 값만 각각 useSelector로 구독한다.

여기에 Node의 memo에 커스텀 비교 함수를 붙여 비교 대상 prop을 명시했고, 드래그 선택 로직은 NodeSelection 컴포넌트로 분리해 캔버스 컴포넌트의 책임을 줄였다.

두 가지 차이를 에디터 축소판으로 옮기면 이렇다. 작은 residual block 그래프에서 노드를 클릭해 선택을 옮기면서 "최적화 전 / 후"를 바꿔 보면, 다시 렌더되는 Node와 Edge가 전체에서 선택과 관련된 몇 개로 줄어드는 것이 보인다.

노드 하나를 선택하면 몇 개가 다시 그려질까
비교 모드

캔버스가 selectedNode 객체와 setter를 모든 Node에, 선택 배열을 모든 Edge에 그대로 내려준다. 선택이 바뀌면 Node 9개와 Edge 9개가 전부 다시 렌더된다.

Input0
Conv0
BatchNorm0
Conv0
Relu0
Conv0
Add0
Relu0
Output0
마지막 렌더에서 다시 그려진 것: Node 0/9 · Edge 0/9
노드를 클릭하거나 호버 시 나오는 i 배지를 눌러 선택을 옮겨 보세요. 노드 오른쪽 숫자는 렌더 횟수, 강조색 깜빡임은 방금 렌더됐다는 뜻입니다.

구현

Node prop을 boolean으로 바꾸고 memo 비교를 명시

변경 전 Node는 선택 객체와 setter를 받아 내부에서 판정했다.

const Node = ({ data, open, setOpen, setSelectedNode, selectedNode, settingData, viewer, tab }) => {
    // ...
    const onClickNode = (e) => {
        setSelectedNode(data);
        setOpen(true);
        e.stopPropagation();
    };
    // ...
    {(showProps || selectedNode.id === data.id) && <PropertyBadge /* ... */ />}
};
export default memo(Node);

변경 후에는 isSelected와 클릭 핸들러 하나만 받고, 비교 함수로 리렌더 조건을 고정했다.

const Node = ({ data, isSelected, settingData, viewer, tab, openNodeProperties }) => {
    // ...
    <NodeContainer onClick={(e) => openNodeProperties(e, "node", data)}>
        {(showProps || isSelected) && (
            <PropertyBadge
                onClickNode={(e) => openNodeProperties(e, "badge", data)}
                isSelected={isSelected}
                tab={tab}
            />
        )}
    </NodeContainer>
};
 
export default memo(Node, (prevProps, nextProps) => {
    // Only re-render if the isSelected prop or the data prop changes
    return (
        prevProps.isSelected === nextProps.isSelected &&
        prevProps.data === nextProps.data &&
        prevProps.settingData === nextProps.settingData &&
        prevProps.viewer === nextProps.viewer &&
        prevProps.tab === nextProps.tab
    );
});

부모의 map에서는 판정만 하고 결과를 넘긴다.

{nodes.map((node, index) => {
    const isSelected = selectedNode.id === node.id;
    return (
        <Node
            key={`node-${index}`}
            data={node}
            isSelected={isSelected}
            settingData={settingData}
            viewer={viewer}
            tab={tab}
            openNodeProperties={openNodeProperties}
        />
    );
})}

Edge도 같은 방식이다. selectedData.find(...)를 useMemo로 감싸 두었던 코드를 지우고, 부모가 계산한 boolean을 받는다.

// 변경 전
const Edge = ({ data, graph, nodes, selectedData, settingData, tab }) => {
    const showTensorInput = useMemo(
        () => selectedData.find((d) => d.id === data.target),
        [selectedData]
    );
    // ...
};
 
// 변경 후
const Edge = ({ data, graph, nodes, isSelected, settingData, tab }) => {
    const showTensorInput = isSelected;
    // ...
};
{edges.map((edge, index) => {
    const isSelected = selectedData.some((d) => d.id === edge.target);
    return <Edge key={`edge-${index}`} data={edge} isSelected={isSelected} /* ... */ />;
})}

리듀서 전체 구독을 슬라이스 구독으로

// 변경 전
const modelReducer = useSelector((state) => state.ModelReducer);
 
// 변경 후
const searchedNode = useSelector((state) => state.ModelReducer.searchedNode[tab] || null);
const editorInfo = useSelector((state) => state.ModelReducer.editorInfo[tab]);
const settingInfo = useSelector((state) => state.ModelReducer.settingInfo);
const actionInfo = useSelector((state) => state.ModelReducer.actionInfo);
const nodesBreakdown = useSelector((state) => state.ModelReducer.nodesBreakdown);
const selectedNodes = useSelector((state) => state.ModelReducer.selectedNodes);

modelReducer.editorInfo[tab].deviceName처럼 리듀서 객체를 타고 들어가던 useEffect 의존성도 전부 editorInfo.deviceName 형태로 바꿨다.

처음에는 "설정이 바뀌었는지" 여부를 네 필드를 합친 셀렉터로 계산했는데, 곧바로 settingInfo 하나만 구독하고 파생값은 useMemo로 옮기는 형태로 고쳤다.

const settingInfo = useSelector((state) => state.ModelReducer.settingInfo);
const isChangedSetting = useMemo(
    () =>
        settingInfo?.overall ||
        settingInfo?.opType ||
        settingInfo?.layer ||
        settingInfo?.changed,
    [settingInfo]
);

드래그 선택 로직 분리

react-selecto 설정과 onDragStart, onSelect 등 콜백을 NodeSelection 컴포넌트로 옮겼다. 이 컴포넌트는 자기가 필요한 settingInfo와 actionInfo.currentSubMenu만 따로 구독한다.

const NodeSelection = ({ tab, selectoRef, graphRef, isInteractive, nodes, /* ... */ }) => {
    const settingInfo = useSelector((state) => state.ModelReducer.settingInfo);
    const currentSubMenu = useSelector(
        (state) => state.ModelReducer.actionInfo?.currentSubMenu
    );
    // ...
    return (
        <Selecto
            ref={selectoRef}
            container={`.flow-${tab}`}
            selectableTargets={[`.flow__node-${tab}`]}
            hitRate={20}
            selectByClick={true}
            selectFromInside={false}
            toggleContinueSelect={[["meta"], ["ctrl"]]}
            // ...
        />
    );
};
export default memo(NodeSelection);

엣지 라벨 위치를 transform 대신 x/y로

부수적으로, 엣지 라벨 위치를 transform="translate(x,y)" 문자열로 만들어 넘기던 것을 x, y 속성으로 직접 지정하도록 바꿨다. 좌표를 문자열로 합치던 코드가 사라지고 객체 하나로 정리됐다.

// 변경 전
const labelPath = edgeLabel.x - labelWidth / 2 + "," + (edgeLabel.y - edgeLabel.height / 2);
// ...
<rect width="16" height="16" transform={`translate(${edgeLabelPath})`} />
 
// 변경 후
const labelPath = {
    x: edgeLabel.x - labelWidth / 2,
    y: edgeLabel.y - edgeLabel.height / 2,
};
// ...
<rect x={edgeLabelPath.x} y={edgeLabelPath.y} width="16" height="16" />

결과

변경 전과 변경 후 코드를 각각 로컬에서 띄우고, 노드 4,381개·엣지 5,104개짜리 ONNX 모델(Stable Diffusion XL UNet)을 올려 같은 동작을 측정했다. Node/Edge/캔버스 컴포넌트 함수 본문에 카운터를 넣어 렌더 횟수를 세고, 클릭 직후 발생한 Long Task 길이로 메인 스레드 점유 시간을 봤다. 측정 동작은 "다른 노드의 속성 배지를 클릭해 선택 노드를 바꾸기"이며 다섯 개 노드에서 반복했다.

변경 전변경 후
선택 변경 시 Node 리렌더4,381개 (전체)2개 (이전 선택 + 새 선택)
선택 변경 시 캔버스 컴포넌트 리렌더1회1회
클릭 직후 Long Task577~814ms50~83ms (없는 경우도 있음)

Node 리렌더는 전체에서 두 개로 줄었다. 남은 50~80ms는 캔버스 컴포넌트가 한 번 리렌더되면서 4,381개 memo 자식의 prop을 비교하는 비용으로 보인다.

측정 조건에 한계가 있다. 개발 빌드라 절대값은 실제 서비스보다 크고, 뷰어 모드라 드래그 선택(react-selecto) 경로는 비활성이어서 Edge 쪽 최적화는 이 측정에 잡히지 않았다(두 버전 모두 Edge 리렌더 0). 상대 비교로만 읽는 것이 맞다.

배포 후 체감으로는 선택 반응뿐 아니라 모델을 처음 열 때 첫 렌더가 끝나는 시간도 눈에 띄게 빨라졌다.

다시 한다면?

컴포넌트 구조와 구독 관리 설계에 처음부터 더 시간을 썼을 것이다. 캔버스 컴포넌트 하나가 리듀서 전체를 구독하고 노드·엣지·선택·줌·메뉴를 모두 들고 있는 구조에서 출발했기 때문에, 최적화가 "무엇을 어디서 구독하고 어떤 prop을 내려줄지"를 뒤늦게 다시 정하는 일이 됐다. 이 판단을 초기에 했다면 Renderer 분리처럼 효과 없는 시도를 거치지 않았을 것이다.

측정하다가 잠재 버그도 하나 찾았다. Node의 memo 비교 함수가 openNodeProperties를 비교 대상에서 빼면서, 선택되지 않은 노드는 첫 렌더 때의 클로저를 계속 들고 있다. 그 클로저 안의 open은 항상 false라서, 속성 패널이 열린 상태에서 다른 노드 본체를 클릭해도 선택이 바뀌지 않는다. 배지 클릭 경로는 open을 보지 않아 정상이다. 비교 대상을 손으로 고르는 memo는 리렌더를 막는 대신 이런 stale closure를 만들 수 있다는 점을 놓치고 있었다.