seon99il

Data Engineering

Apache Spark Deep Dive: Shuffle

7분 소요

Spark에서 Shuffle이 어떤 단계를 거쳐서 일어나고 각 단계마다 파티션이 어떻게 변하는지 알아보겠습니다.

Spark Executor & Slot(Core)

Spark는 Driver 외 N개의 Executor와 M개의 Slot(Core)로 구성되어 있습니다.

  • --num-executors : Executor 수
  • --executor-cores : Executor Core 수
  • --executor-memory : Executor Memory 할당

만약 Executor 3개, Core 수를 3개로 설정했다면 한 번에 병렬처리할 수 있는 파티션(Partition)은 9개(NM = 9)가 됩니다.

Core 당 하나의 Partition을 처리합니다

Executor Memory

--executor-memory를 통해 할당한 메모리(JVM), Heap 메모리 영역은 모든 Core가 공유합니다.

하나의 Executor(memory: 1GB)를 생성하게 되면 서버(Worker)에서는 다음과 같이 메모리를 할당합니다.

  • Executor Memory (Heap): 1024MB (설정한 크기)
  • Memory Overhead (Off-heap): 384MB (max( (heap/10), 384 ))

Overhead(Off-heap)

이 off-heap 메모리는 다음과 같은 필수적인 작업을 위해 사용됩니다.

  • NIO Buffers: 셔플(Shuffle) 시 데이터를 네트워크로 주고받을 때 사용하는 버퍼
  • Thread Stacks: 각 스레드가 사용하는 스택 메모리
  • Direct Memory: JVM 힙을 거치지 않고 OS 메모리를 직접 사용하는 경우
  • PySpark: (Python 사용 시) Python 프로세스가 사용하는 메모리의 일부가 이 영역에 포함될 수 있습니다.

How Spark Shuffle Works

본론으로 돌아와서 Spark의 Shuffle은 사실 2가지 단계를 거쳐서 완성됩니다.

  • Map Phase (Shuffle Write)
  • Reduce Phase (Shuffle Read)
user_schema = StructType([
    StructField("user_id", IntegerType(), False),
    StructField("name", StringType(), True),
    StructField("city", StringType(), True),
    StructField("age", IntegerType(), True)
])

user_data = [
    (1, "Alice", "Seoul", 28),
    (2, "Bob", "Busan", 35),
    (3, "Charlie", "Seoul", 42),
    (4, "David", "Incheon", 22),
    (5, "Eve", "Busan", 31)
]

users_df = spark.createDataFrame(user_data, user_schema)

.config("spark.sql.adaptive.enabled", "false") 이해를 돕기 위해 AQE를 사용하지 않고 진행했습니다.

Stage 1: Map Side (Shuffle Write)

이 단계는 Shuffle을 준비하기 위해 보내는 Core에서 발생하며, 설정된 파티션 수(default: 200)에 맞춰 Hash Partition 합니다.

이 말은 1, 2, 3, 4, 5 아이디를 가진 사용자 데이터를 group by("userId")하게 된다면, 각 사용자 아이디는 Hash값((hash(userId) % 200))을 기준으로 특정 파티션에 위치하게 됩니다.

여기서 파티셔닝은 결정적이며 같은 수의 파티션, 같은 키를 가지고 파티셔닝을 할 경우 항상 특정 키는 특정한 번호의 파티션에 위치하게 됩니다.

userId가 1인 사용자를 userId, 200개의 파티션을 기준으로 파티셔닝한다면 항상 동일한 파티션 ID(43)에 위치하게 됩니다.

result.select(
    F.spark_partition_id().alias("partition_id")
    , F.col("user_id")
    , F.col("count")).show()

이 말은 즉 주문 테이블, 사용자 주소 테이블 어떤 테이블이든 사용자 아이디 + 200개라는 동일한 조건으로 Hash Partitioning하면 43번 Partition 외에 다른 어떤 파티션에서도 user_id = 1인 데이터를 찾을 수 없음을 의미하며, Join 또는 집계 작업을 할 때 user_id=1에 대해서는 43번 파티션만을 참조하면 된다는 것을 의미합니다.

Shuffle Write의 파일 구조

3개의 Upstream Partition을 대상으로 Shuffle Write를 한다면 PartitionedPairBuffer(셔플 버퍼)를 통해서 일정량(Chunk) 단위로 디스크에 다음과 같이 파일이 생성됩니다.

spark.local.dir/blockmgr-{uuid}/
  shuffle_0_0.data    <- All partitions from map task 0, concatenated
  shuffle_0_0.index   <- Byte offsets for quick lookup
  shuffle_0_1.data    <- All partitions from map task 1
  shuffle_0_1.index
  shuffle_0_2.data    <- All partitions from map task 2
  shuffle_0_2.index

각 Task는 각각의 2개의 파일(인덱스, 데이터 파일)을 작성하며, .index 파일에는 위에서 정의한 오프셋(numOfpartition: 200)이 저장되어 Reduce에서 원하는 파티션을 빠르게 찾을 수 있도록 합니다.

Disk에 작성된 MapOutput(HashPartition(user_id, 200))은 SparkDriver에 있는 MapOutputTrackerMaster를 통해서 어디에 해당 Map Side(repartition) 결과가 저장되어 있는지 추적할 수 있으며, 이를 통해서 해당 파티션을 기준으로 하는 Reduce Side(count, write) 작업을 처리할 때 중복된 작업인 Repartition(Map Stage)을 한 번만 처리할 수 있습니다. (Skipped Stage)

Stage 2: Reduce Side (Shuffle Read)

Shuffle Read는 특정 파티션을 한 곳으로 모아서 처리하는 Core(Slot)에서 발생하며, 자신이 담당한 파티션의 데이터를 모두 읽어옵니다.

앞서 얘기한 것처럼 파티션 1개는 하나의 Core에서 담당합니다. 43번 partition을 담당하기로 배정받았다면, 모든 분산되어 있는 서버를 돌며 해당 서버의 43번 Partition의 데이터를 모아 집계(count, sum) 처리를 하면 사용자 아이디 1번에 대한 결과를 확인할 수 있습니다.

이것을 Shuffle Read라고 합니다.

Q: Partition은 몇 개가 생성될까요?

A: 기본 설정 값이 200개가 생성됩니다. (5개 + 195개의 빈 파티션)

사용자 아이디는 5개뿐이지만 기본값으로 설정된 200개의 파티션이 생성되며, 이는 빈 파티션을 대상으로 195개의 Task가 실행되는 성능 저하를 발생시킵니다.

result.rdd.getNumPartitions()

# 200

AQE(Adaptive Query Execution)를 활용하여 작은 크기 파티션을 대상으로 하는 Task 줄이기

여기서 AQE가 활성화되어 있다면(기본적으로 True), AQE의 개입으로 성능 저하를 방지할 수 있습니다.

Adaptive Query Execution (AQE) is an optimization technique in Spark SQL that makes use of the runtime statistics to choose the most efficient query execution plan, which is enabled by default since Apache Spark 3.2.0. Spark SQL can turn on and off AQE by spark.sql.adaptive.enabled as an umbrella configuration.

Performance Tuning — Spark offers many techniques for tuning the performance of DataFrame or SQL workloads. Those techniques, broadly…

위의 예제같이 작은 파티션들을 하나의 Task에서 읽을 수 있도록 파티션을 AQEShuffleRead coalesced라는 이름으로 줄여줍니다.

Web UI — AQE, result.select(partition_id, …)

200개로 쪼개져 있던 파티션을 하나로 Coalesce 해주면서 이 모든 파티션에 200개의 Task가 실행되는 것이 아닌 하나의 Task가 실행되도록 튜닝해줍니다.

Shuffle Write 단계에서는 변함없이 200개의 Partition이 생깁니다. 단, AQE를 통해 Shuffle Read에서의 성능 향상을 기대할 수 있습니다.

Shuffle Write: Hash Aggregate

Hash Aggregate란 Shuffle Write 시 모든 데이터의 원본을 파티셔닝하는 것이 아닌 미리 그룹된 결과를 파티션에 넣어 네트워크 비용을 줄이는 방법입니다.

사용자 아이디 기준으로 count

user_id | name | city | age를 파티션에 넣어 보내는 것이 아니라, 자기가 담당하는 파티션에서 미리 계산 후 계산된 결과를 파티션에 넣어 준비합니다.

[{
  user_id: 1,
  count:  1,
},
{
  user_id: 2,
  count:  1,
},
{
  user_id: 3,
  count:  1,
}
...
]

그 후 데이터가 이동(Shuffle Read)되면 네트워크 IO를 줄일 수 있습니다.

Hash Aggregate의 Number Of Output rows에 대해서

주문 데이터를 대상으로 사용자 아이디를 기준으로 group by 해보겠습니다.

order_data = [
    (101, 1, "Laptop", 1200.00, datetime(2025, 11, 15, 10, 0, 0)),
    (102, 2, "Mouse", 25.50, datetime(2025, 11, 15, 12, 30, 0)),
    (103, 1, "Monitor", 350.99, datetime(2025, 11, 16, 9, 0, 0)),
    (104, 3, "Keyboard", 75.00, datetime(2025, 11, 16, 15, 0, 0)),
    (105, 5, "Webcam", 50.00, datetime(2025, 11, 17, 11, 0, 0)),
    (106, 1, "Headset", 99.99, datetime(2025, 11, 17, 14, 0, 0)),
    (107, 6, "Charger", 15.00, datetime(2025, 11, 18, 10, 0, 0))
]

orders_df = spark.createDataFrame(order_data, order_schema)
orders_df.rdd.getNumPartitions()

# Partition_cnt: 12
orders_df.groupBy("user_id").count().show()

Q: 이러면 Hash Aggregate 후 몇 개의 Row가 전송될까요? A: 정답은 5 ~ 7개입니다.

result of orders_df.groupBy(“user_id”).count().show()

그 이유는 파티션 수에 있는데요, 만약 데이터가 모두 한 파티션에 모여 있다면 1, 2, 3, 5, 6 이렇게 5개로 그룹핑 후 전송할 수 있습니다.

하지만, 만약 다른 파티션에 값이 있다면 어떻게 될까요? Partition1(1, 2, 1), Partition2 (3, 5, 1, 6) 이렇게 데이터가 분포되어 있다면, 파티션 1에서는 2개의 데이터, 파티션 2에서는 4개의 데이터 총 6개의 Row가 이동하게 됩니다.

(orders_df.groupBy(F.spark_partition_id())
          .agg(F.collect_list("user_id"))
          .show(truncate=False)
)

7개의 파티션에 나뉘어 있기 때문에 Hash Aggregate의 결과가 7개가 됨

coalesce(1)로 모든 파티션을 하나로 합치면 Shuffle이 일어날까?

spark.read로 읽었을 때 파티션이 하나인 것과 coalesce(1)로 하나로 합쳤을 때 셔플링이 어떻게 발생하는지 비교해보겠습니다.

orders_df = orders_df.coalesce(1)
users_df = users_df.coalesce(1)

result = orders_df.join(users_df, on="user_id", how="inner")
result.show()

결과는 Shuffle이 발생하지 않습니다.

각각 다른 서버에 있던 user 데이터와 order 데이터가 하나의 서버로 이동하는 것은 맞지만 이것을 Spark에서 shuffle이라고 부르지 않습니다.

spark.read 후 파티션이 1개인 테이블 간의 Join

이제 spark.read를 했을 때 partition이 1개라면 위와 같이 Shuffle이 발생할지 안 할지 확인해보겠습니다.

order_df = spark.read.schema(order_schema).parquet("./data/work/orders")
user_df = spark.read.schema(user_schema).parquet("./data/work/users")

order_df.rdd.getNumPartitions(), user_df.rdd.getNumPartitions()

# (1, 1)
result = order_df.join(user_df, on="user_id", how="inner")
result.show()

Result

Spark의 개입으로 Broadcast Hash Join이 되었지만 만약 Spark의 개입이 없었다면(spark.conf.set("spark.sql.autoBroadcastJoinThreshold", -1) 등) Shuffle이 발생했을 겁니다. 왜 같은 1개의 파티션에 다른 결과가 나오는 걸까요?

파티셔닝 규칙 조회하기

사실 보기에는 같아 보이지만(파티션 1개) 내부적으로 확인해보면 다른 파티션 규칙을 가지고 있는 것을 확인할 수 있습니다.

# spark.read (partition : 1개)
order_df = spark.read.schema(order_schema).parquet("./data/work/orders")
print("Plain:", order_df._jdf
      .queryExecution()
      .executedPlan()
      .outputPartitioning())

# Plain: UnknownPartitioning(0)
# coalesce(1) (partition: 1개)
order_df = order_df.coalesce(1)
print("Plain:", order_df._jdf
      .queryExecution()
      .executedPlan()
      .outputPartitioning())

# Plain: SinglePartition

단순히 읽어서 파티션 1개가 된 DataFrame을 대상으로는 Spark는 SinglePartition을 보장하지 못하기 때문에 같은 파티션 1개의 DataFrame이라고 해도 위와 같이 다른 결과가 발생합니다.

이전 글

전체 글 보기 →

댓글