seon99il

Data Engineering

Apache Spark Memory Deep Dive: 브로드캐스트 변수의 배신과 OOM 해결기

11분 소요

발단: 단순한 로직이 불러온 파이프라인 병목

최근 Apache Spark기반의 데이터 파이프라인을 구축 과정에서, 내 비정형화된 국가명(예: Korea, Ko, ko 등)을 정형화된 국가 코드(Korea)로 추출하고 집계하는 로직을 개발하게 되었습니다.

논리 자체는 매우 단순했습니다. 라이브러리를 활용해 Python 딕셔너리 형태의 매핑 규칙을 정의하고, 이를 UDF(.map)을 통해 치환하는 것입니다.

하지만 처리해야 할 데이터가 많아지자, 이 단순한 딕셔너리 매핑 로직이 Executor의 메모리를 점유하고 심각한 성능 지연을 유발하는 병목 지점이 되었습니다.

여기서 생긴 궁금증은…

“브로드캐스팅된 변수는 Storage Memory 영역에 Executor 단위로 한 번 저장되지만, 파이썬 워커에서 해당 변수를 사용할 때 역직렬화되기 때문에 워커 수만큼 데이터가 복제되지 않을까?”

이를 해결, 검증하기 위해 딕셔너리 데이터를 각 Executor에 전달하는 방식을 세 가지로 나누어 고민했습니다.

  • Closure 변수로 캡슐화하여 .map 내부에서 호출하는 방식
  • Spark Broadcast Variable로 선언하여 명시적으로 전달하는 방식
  • 매핑 룰 자체를 DataFrame으로 생성하여 JVM 레벨에서 Broadcast Hash Join (BHJ)을 수행하는 방식

이 글에서는 위 세 가지 방식이 PySpark 환경의 Driver와 Executor 사이에서 어떻게 직렬화/역직렬화되며, 메모리를 어떻게 점유하는지 직접 가설을 세우고 로그를 통해 내부 동작(Internals)을 파헤친 과정을 공유합니다.

글 하단에서 전체 코드를 확인할 수 있습니다.

테스트 환경

  • Spark: 3.5.1 (PySpark)
  • Python: 3.12
  • Cluster: local-cluster[2,2,1024] (Executor 2개, 코어 2개, 16 파티션 처리)

배경 지식: PySpark의 실행 구조와 메모리 공유의 한계

PySpark의 Executor 프로세스는 JVM 기반이므로 Python 코드를 직접 실행할 수 없습니다. 따라서 Executor는 로컬 소켓(Socket) 통신을 통해 별도의 Python Worker 프로세스와 데이터를 주고받아야 합니다.

PySpark Python UDF Workflow

  • JVM Executor가 태스크를 수신하면, 노드에 pyspark.daemon 프로세스가 있는지 확인합니다.
  • Executor는 데몬에게 워커 생성을 요청하고, pyspark.daemon은 Linux의 os.fork()를 호출하여 자신을 복제한 Python Worker Process를 생성합니다.

여기서 한 가지 가설을 세웠습니다. 만약 거대한 딕셔너리를 파이썬 워커로 넘긴다면, Linux의 COW(Copy-On-Write) 이점을 얻어 메모리가 공유될까? 결론부터 말하자면 불가능합니다. pyspark.daemon은 포크되는 시점에 실제 데이터를 들고 있지 않으며, 데이터는 워커가 생성된 후 개별적으로 로드되기 때문입니다.

그렇다면 데이터가 전달되는 ‘방식’에 따라 파이썬 워커의 메모리 상태는 어떻게 달라질까요? 이를 확인하기 위해 메모리 점유량(RSS)과 객체 ID를 추적하는 커스텀 클래스(Tracker)를 작성하여 검증에 돌입했습니다.

가설 검증 1: Python Closure 변수의 메모리 생명 주기

가장 흔하게 실수하는 패턴인 외부 변수(Closure) 참조 방식입니다. 전역으로 선언된 큰 딕셔너리나 객체를 map 함수 내부에서 바로 참조할 때 Spark는 이를 어떻게 처리할까요?

spark = (
    SparkSession.builder.master("local-cluster[2,2,1024]")
    .appName("ClosureTest")
    .config("spark.python.worker.reuse", "true")
    .getOrCreate()
)
sc = spark.sparkContext
closure_obj = Tracker("Closure", payload_size_mb=100)

...

def task(partition_idx, iterator):

    before = rss_mb()

    obj = closure_obj

    obj.counter += 1

    after = rss_mb()

    list(iterator)

    return [
        {
          ...
        }
    ]

result = rdd.mapPartitionsWithIndex(task).collect()

처음에는 “수백 개의 Task(파티션)가 실행될 때마다 Driver가 일일이 RPC 통신으로 변수를 쏴주지 않을까?”라고 의심했습니다. 하지만 Spark의 DAGScheduler 로그를 뜯어본 결과, 제 예상은 반만 맞았습니다.

# Tracker Log

    DRIVER
    pid=2077
    host=Seonggils-MacBook-Pro.local

            CREATE
            mode=Closure
            pid=2077
            host=Seonggils-MacBook-Pro.local
            obj_id=4528186352

            SERIALIZE
            mode=Closure
            serialize_idx=1
            pid=2077
            host=Seonggils-MacBook-Pro.local
            obj_id=4528186352
            size=100.00MB

...

# DAGScheduler Log
# --- Executor ---

INFO BlockManagerInfo: Added broadcast_0_python on disk on :50002 (size: 100.0 MiB)
INFO BlockManagerInfo: Added broadcast_0_python on disk on :50003 (size: 100.0 MiB)

Spark는 수많은 Task를 RPC로 전송할 때 발생하는 Driver의 네트워크 병목을 막기 위해, Task와 클로저가 직렬화된 바이트 배열(taskBinary) 자체를 Broadcast 변수로 만들어 각 Executor(JVM)에 단 한 번만 전송하는 최적화를 수행하고 있었습니다.

하지만 문제는 Python Worker 프로세스에서 시작되었습니다.

# Closure Result

================================================================================
RESULT
================================================================================
{'partition': 0, 'pid': 9044, 'object_id': 4452912544, 'counter': 1, 'rss_before': 234.15625, 'rss_after': 234.21875, 'rss_delta': 0.0625}
{'partition': 1, 'pid': 9045, 'object_id': 4452912544, 'counter': 1, 'rss_before': 234.21875, 'rss_after': 234.265625, 'rss_delta': 0.046875}
{'partition': 2, 'pid': 9040, 'object_id': 4398518144, 'counter': 1, 'rss_before': 234.1875, 'rss_after': 234.25, 'rss_delta': 0.0625}
{'partition': 3, 'pid': 9041, 'object_id': 4398518144, 'counter': 1, 'rss_before': 234.21875, 'rss_after': 234.28125, 'rss_delta': 0.0625}
{'partition': 4, 'pid': 9042, 'object_id': 4555782432, 'counter': 1, 'rss_before': 234.1875, 'rss_after': 234.234375, 'rss_delta': 0.046875}
{'partition': 5, 'pid': 9043, 'object_id': 4454748032, 'counter': 1, 'rss_before': 234.21875, 'rss_after': 234.265625, 'rss_delta': 0.046875}
{'partition': 6, 'pid': 9041, 'object_id': 4506131472, 'counter': 1, 'rss_before': 272.328125, 'rss_after': 272.328125, 'rss_delta': 0.0}
{'partition': 7, 'pid': 9040, 'object_id': 4506131424, 'counter': 1, 'rss_before': 272.40625, 'rss_after': 272.40625, 'rss_delta': 0.0}
{'partition': 8, 'pid': 9041, 'object_id': 4506128976, 'counter': 1, 'rss_before': 272.765625, 'rss_after': 272.765625, 'rss_delta': 0.0}
{'partition': 9, 'pid': 9040, 'object_id': 4506128928, 'counter': 1, 'rss_before': 272.890625, 'rss_after': 272.890625, 'rss_delta': 0.0}
{'partition': 10, 'pid': 9040, 'object_id': 4506130752, 'counter': 1, 'rss_before': 273.0, 'rss_after': 273.0, 'rss_delta': 0.0}
{'partition': 11, 'pid': 9041, 'object_id': 4506128112, 'counter': 1, 'rss_before': 272.859375, 'rss_after': 272.859375, 'rss_delta': 0.0}
{'partition': 12, 'pid': 9040, 'object_id': 4506130176, 'counter': 1, 'rss_before': 273.15625, 'rss_after': 273.15625, 'rss_delta': 0.0}
{'partition': 13, 'pid': 9041, 'object_id': 4506130560, 'counter': 1, 'rss_before': 272.859375, 'rss_after': 272.859375, 'rss_delta': 0.0}
{'partition': 14, 'pid': 9040, 'object_id': 4506129552, 'counter': 1, 'rss_before': 273.328125, 'rss_after': 273.328125, 'rss_delta': 0.0}
{'partition': 15, 'pid': 9041, 'object_id': 4506130704, 'counter': 1, 'rss_before': 272.859375, 'rss_after': 272.859375, 'rss_delta': 0.0}

워커 재사용 설정(spark.python.worker.reuse=true)이 되어 있어 동일한 PID(9040) 위에서 여러 파티션이 처리됨에도 불구하고, Object ID가 매 파티션마다 달라지고 Counter는 항상 1로 초기화되었습니다.

이유는 PySpark의 역직렬화 메커니즘 때문입니다. JVM에서 Python Worker로 Task가 할당될 때마다, 워커는 전달받은 클로저 바이트 배열을 cloudpickle.loads()를 통해 매번 새로 Unpickle(역직렬화)하여 메모리에 적재합니다. 즉, 300MB 크기의 클로저가 있고 50개의 파티션(Task)을 처리해야 한다면, 파이썬 워커는 300MB 객체를 50번이나 메모리에 생성하고 버리기를 반복합니다. 이는 극심한 가비지 컬렉션(GC) 오버헤드와 OOM의 주범이 됩니다.

가설 검증 2: Broadcast Variable: 워커 레벨의 캐싱 로직

그렇다면 Broadcast Variable을 명시적으로 사용하면 Worker 측의 동작은 어떻게 달라질까요?

spark: SparkSession = (
    SparkSession.builder.master("local-cluster[2,2,1024]")
    .appName("BroadcastTest")
    .config("spark.python.worker.reuse", "true")
    .getOrCreate()
)
sc = spark.sparkContext
broadcast_obj = Tracker("Broadcast", payload_size_mb=100)
bc = sc.broadcast(broadcast_obj)

...

def task(partition_idx, iterator):

    before = rss_mb()
    obj = bc.value
    obj.counter += 1
    after = rss_mb()

    list(iterator)

    return [
        {
          ...
        }
    ]

result = rdd.mapPartitionsWithIndex(task).collect()

결과는 명확한 차이를 보였습니다. 동일한 PID(Worker)를 기준으로, 브로드캐스트 변수가 최초 로드될 때만 1번 메모리(RSS)가 증가하고, 이후 다른 파티션을 처리할 때는 메모리 증가가 0이었습니다. Object ID가 동일하게 유지되며 Counter 값이 누적되는 것을 통해, 객체가 메모리에 캐싱되어 완벽하게 재사용됨을 알 수 있습니다.

# Broadcast Result
================================================================================
RESULT
================================================================================
{'partition': 0, 'pid': 9108, 'object_id': 4566676736, 'counter': 1, 'rss_before': 30.640625, 'rss_after': 133.984375, 'rss_delta': 103.34375}
{'partition': 1, 'pid': 9109, 'object_id': 4565405856, 'counter': 1, 'rss_before': 30.8125, 'rss_after': 134.171875, 'rss_delta': 103.359375}
{'partition': 2, 'pid': 9107, 'object_id': 4565564832, 'counter': 1, 'rss_before': 30.90625, 'rss_after': 134.359375, 'rss_delta': 103.453125}
{'partition': 3, 'pid': 9106, 'object_id': 4554549072, 'counter': 1, 'rss_before': 30.8125, 'rss_after': 134.28125, 'rss_delta': 103.46875}
{'partition': 4, 'pid': 9107, 'object_id': 4565564832, 'counter': 2, 'rss_before': 172.515625, 'rss_after': 172.515625, 'rss_delta': 0.0}
{'partition': 5, 'pid': 9106, 'object_id': 4554549072, 'counter': 2, 'rss_before': 172.59375, 'rss_after': 172.59375, 'rss_delta': 0.0}
{'partition': 6, 'pid': 9107, 'object_id': 4565564832, 'counter': 3, 'rss_before': 173.09375, 'rss_after': 173.09375, 'rss_delta': 0.0}
{'partition': 7, 'pid': 9106, 'object_id': 4554549072, 'counter': 3, 'rss_before': 173.0625, 'rss_after': 173.0625, 'rss_delta': 0.0}
{'partition': 8, 'pid': 9106, 'object_id': 4554549072, 'counter': 4, 'rss_before': 173.171875, 'rss_after': 173.171875, 'rss_delta': 0.0}
{'partition': 9, 'pid': 9107, 'object_id': 4565564832, 'counter': 4, 'rss_before': 173.109375, 'rss_after': 173.109375, 'rss_delta': 0.0}
{'partition': 10, 'pid': 9107, 'object_id': 4565564832, 'counter': 5, 'rss_before': 173.234375, 'rss_after': 173.234375, 'rss_delta': 0.0}
{'partition': 11, 'pid': 9106, 'object_id': 4554549072, 'counter': 5, 'rss_before': 173.1875, 'rss_after': 173.1875, 'rss_delta': 0.0}
{'partition': 12, 'pid': 9109, 'object_id': 4565405856, 'counter': 2, 'rss_before': 172.546875, 'rss_after': 172.546875, 'rss_delta': 0.0}
{'partition': 13, 'pid': 9108, 'object_id': 4566676736, 'counter': 2, 'rss_before': 172.40625, 'rss_after': 172.40625, 'rss_delta': 0.0}
{'partition': 14, 'pid': 9107, 'object_id': 4565564832, 'counter': 6, 'rss_before': 173.234375, 'rss_after': 173.234375, 'rss_delta': 0.0}
{'partition': 15, 'pid': 9106, 'object_id': 4554549072, 'counter': 6, 'rss_before': 173.1875, 'rss_after': 173.1875, 'rss_delta': 0.0}

PySpark 내부적으로 .value가 최초 호출될 때 로컬 디스크의 브로드캐스트 파일을 읽어 역직렬화한 뒤, 이를 워커의 전역 컨텍스트(_broadcastRegistry)에 저장해두기 때문입니다. 클로저 방식처럼 매 파티션마다 객체를 재생성하는 비효율은 완벽히 제거되었습니다. 하지만 초기에 예상했던 파이썬 워커 수(코어 수)만큼 메모리에 중복 복제되는 한계를 확인할 수 있었습니다.

파이썬 워커를 재사용하지 않으면(“spark.python.worker.reuse”, “false”), 클로저 변수와 동일(counter: 1)하게 동작합니다.

가설 검증 3: 대규모 데이터의 정답, Broadcast Hash Join (BHJ)

마지막으로, Python 객체로 넘기는 대신 딕셔너리를 DataFrame으로 만들어 Spark SQL 엔진에서 Broadcast Hash Join을 수행하는 경우를 확인했습니다.

이 경우 아예 데이터가 파이썬 워커의 메모리 공간으로 넘어가지 않습니다. Spark의 물리적 실행 엔진(Tungsten)이 JVM 내에서 자체적인 메모리 포맷(UnsafeRow)을 활용하여 조인을 처리합니다.

Executor Heap Histogram 분석 결과:

# Executor Heap Histogram
# Rank | Instances | Bytes | Class Name

1882 | 1 | 24 | org.apache.spark.sql.execution.joins.LongHashedRelation

결과가 보여주듯, 각 Executor의 JVM 힙 메모리 공간에 LongHashedRelation 객체가 단 1개만 인스턴스화되어 모든 Core(Task)가 이를 공유합니다. Python과 JVM 사이의 직렬화/역직렬화 통신 비용이 전혀 발생하지 않으며, 코어 수만큼 데이터가 복제되지도 않는 가장 이상적인 상태입니다.

결론 및 요약

위의 로깅과 코드 분석을 바탕으로, PySpark 환경에서 참조해야 할 메타데이터를 전달하는 아키텍처 전략을 다음과 같이 정리할 수 있습니다.

이를 통해서 Column/Row 형태의 데이터나 큰 데이터를 전송하는 상황에서 단순히 Broadcast Variable로 전달하는 것이 아닌 상황에 따라 Broadcast Hash Join으로 처리하는 것도 고려해보면 좋을 거 같습니다.

Closure Variable

  • 네트워크 전송: JVM까지는 Broadcast로 1회 전송
  • 파이썬 메모리 적재: 매 Task(파티션)마다 새롭게 Unpickle
  • 단점: 처리 파티션 수만큼 객체 생성/파괴 반복 (극심한 GC 발생)

Broadcast Variable

  • 네트워크 전송: JVM까지 Broadcast 1회 전송
  • 파이썬 메모리 적재: Worker Process(PID)당 최초 1회 적재
  • 단점: Core 수(Worker 수)만큼 메모리에 데이터 복제됨

Broadcast Hash Join

  • 네트워크 전송: JVM까지 Broadcast 1회 전송
  • 파이썬 메모리 적재: Python Worker로 데이터 전송 안 됨
  • 단점: 테이블로 관리 시 네트워크 I/O 발생, 동적 생성 시 Driver 부담 발생

참조

  • DAGScheduler의 Task Broadcast 로직: 드라이버의 네트워크 병목을 방지하기 위해 submitMissingTasks 내부에서 직렬화된 Task Binary 객체를 한 번만 브로드캐스팅하는 최적화 로직
  • pyspark.daemon 프로세스 포크 (Process Fork): JVM Executor의 요청을 받아 리눅스의 os.fork()를 통해 실제 파이썬 워커 프로세스를 생성해 내는 백그라운드 데몬의 동작을 확인
  • Python Worker의 역직렬화(Unpickle): 파이썬 워커가 JVM으로부터 Task를 전달받을 때마다 read_command 함수 등에서 바이트 배열을 파이썬 객체로 역직렬화(cloudpickle 등 활용)하여 메모리에 적재
  • Broadcast Hash Join의 LongHashedRelation: JVM 내의 Tungsten 엔진에서 조인을 처리하기 위해 단 1개만 생성하여 재사용하는 해시 테이블 구조체

전체 코드

  • tracker.py
import os
import pickle
import socket

class Tracker:
    serialize_count = 0

    def __init__(self, mode_name, payload_size_mb=100):

        self.mode_name = mode_name

        self.counter = 0

        self.payload = b"x" * payload_size_mb * 1024 * 1024

        print(
            f"""
            CREATE
            mode={mode_name}
            pid={os.getpid()}
            host={socket.gethostname()}
            obj_id={id(self)}
            """
        )

    def __getstate__(self):

        Tracker.serialize_count += 1

        size_mb = len(pickle.dumps(self.__dict__)) / 1024 / 1024

        print(
            f"""
            SERIALIZE
            mode={self.mode_name}
            serialize_idx={Tracker.serialize_count}
            pid={os.getpid()}
            host={socket.gethostname()}
            obj_id={id(self)}
            size={size_mb:.2f}MB
            """
        )

        return self.__dict__
  • test_closure.py
import os
import socket

import psutil
from tracker import Tracker

from pyspark.sql import SparkSession

def rss_mb():
    return psutil.Process(os.getpid()).memory_info().rss / 1024 / 1024

spark = (
    SparkSession.builder.master("local-cluster[2,2,1024]")
    .appName("ClosureTest")
    .config("spark.python.worker.reuse", "true")
    .getOrCreate()
)

sc = spark.sparkContext
sc.setLogLevel("DEBUG")

sc.addPyFile("tracker.py")

print(
    f"""
    DRIVER
    pid={os.getpid()}
    host={socket.gethostname()}
    """
)

closure_obj = Tracker("Closure", payload_size_mb=1)

rdd = sc.parallelize(range(16), 16)

def task(partition_idx, iterator):

    before = rss_mb()

    obj = closure_obj

    obj.counter += 1

    after = rss_mb()

    list(iterator)

    return [
        {
            "partition": partition_idx,
            "pid": os.getpid(),
            "host": socket.gethostname(),
            "object_id": id(obj),
            "counter": obj.counter,
            "rss_before": before,
            "rss_after": after,
            "rss_delta": after - before,
        }
    ]

result = rdd.mapPartitionsWithIndex(task).collect()

print("\n")
print("=" * 80)
print("RESULT")
print("=" * 80)

for row in sorted(result, key=lambda x: x["partition"]):
    print(row)

spark.stop()
  • test_broadcast.py
import os
import socket

import psutil
from tracker import Tracker

from pyspark.sql import SparkSession

def rss_mb():
    return psutil.Process(os.getpid()).memory_info().rss / 1024 / 1024

spark = (
    SparkSession.builder.master("local-cluster[2,2,1024]")
    .appName("BroadcastTest")
    .config("spark.python.worker.reuse", "true")
    .getOrCreate()
)

sc = spark.sparkContext
sc.setLogLevel("DEBUG")

sc.addPyFile("tracker.py")

print(
    f"""
    DRIVER
    pid={os.getpid()}
    host={socket.gethostname()}
    """
)

broadcast_obj = Tracker("Broadcast", payload_size_mb=1)
bc = sc.broadcast(broadcast_obj)

rdd = sc.parallelize(range(16), 16)

def task(partition_idx, iterator):

    before = rss_mb()

    obj = bc.value

    obj.counter += 1

    after = rss_mb()

    list(iterator)

    return [
        {
            "partition": partition_idx,
            "pid": os.getpid(),
            "host": socket.gethostname(),
            "object_id": id(obj),
            "counter": obj.counter,
            "rss_before": before,
            "rss_after": after,
            "rss_delta": after - before,
        }
    ]

result = rdd.mapPartitionsWithIndex(task).collect()

print("\n")
print("=" * 80)
print("RESULT")
print("=" * 80)

for row in sorted(result, key=lambda x: x["partition"]):
    print(row)

spark.stop()

이전 글

전체 글 보기 →

댓글