Folly Code Review · 21/89

folly Zero-copy 패턴 — IOBuf로 ScatterGather I/O 표현

2026년 6월 5일 · Hawk · 4분 읽기

cpp folly iobuf zero-copy network

Twitter LinkedIn

한 줄 요약: IOBuf chain은 그 자체로 iovec다. writev/readv/sendmsg에 직접 넘겨 user-space copy를 0회로 만든다.

#동기 — copy가 비용이다

10Gbps 네트워크에서 매초 1GB의 byte가 흐른다. user-space에서 1번 복사하면 추가 1GB/s memcpy다. CPU 한 코어를 통째로 잡아먹는다.

전통적 흐름 — kernel↔user 사이에 user buf1/buf2/socket buf 거치며 여러 번 memcpy

zero-copy 목표는 user-space에서 0번 copy다.

zero-copy 흐름 — IOBuf가 pointer만 wrap해 chain으로 연결되고 writev/sendmsg에 직접 전달

IOBuf의 ref-count와 chain 구조가 이를 자연스럽게 표현한다.

#패턴 1 — recv + IOBufQueue

1
folly::IOBufQueue q{folly::IOBufQueue::cacheChainLength()};
2

3
while (running) {
4
  auto [data, cap] = q.preallocate(4096, 65536);
5
  ssize_t n = ::recv(fd, data, cap, 0);
6
  if (n <= 0) break;
7
  q.postallocate(n);
8

9
  // q의 chain은 추가 copy 없이 frame parser로 흐름
10
  while (auto frame = parseFrame(q)) {
11
    handle(std::move(frame));
12
  }
13
}

recv가 직접 IOBuf의 buffer에 쓴다. user-space copy 0회.

#패턴 2 — writev로 chain 전체 송신

1
ssize_t writeChain(int fd, folly::IOBuf const* head) {
2
  std::array<iovec, 64> iov;
3
  size_t count = 0;
4
  size_t total = 0;
5
  auto cur = head;
6
  do {
7
    iov[count].iov_base = const_cast<uint8_t*>(cur->data());
8
    iov[count].iov_len = cur->length();
9
    total += cur->length();
10
    ++count;
11
    cur = cur->next();
12
  } while (cur != head && count < iov.size());
13

14
  ssize_t n = ::writev(fd, iov.data(), count);
15
  return n;   // partial write 처리는 별도
16
}

writev 한 번에 chain 전체가 송신된다. 각 IOBuf를 별도 copy하지 않는다.

Folly의 AsyncSocket::writeChain()이 이 패턴을 추상화한다.

#패턴 3 — protocol layer stack

1
// HTTP response = header + body
2
auto header = serializeHeader(...);   // IOBuf
3
auto body = std::move(bodyChain);     // IOBuf chain (file에서 읽음)
4

5
// prepend → 복사 없이 chain 앞에 잇기
6
header->prependChain(std::move(body));
7

8
socket->writeChain(std::move(header));

header를 body 앞에 prepend할 때 copy가 0회다. linked list에 노드를 잇는 것뿐이다.

#패턴 4 — file → socket (sendfile 보완)

sendfile은 kernel 안에서 file → socket을 보낸다. user-space를 전혀 거치지 않는다.

1
// sendfile은 raw fd로 — IOBuf와 무관
2
ssize_t n = ::sendfile(socketFd, fileFd, &offset, count);

그러나 header를 함께 보내야 한다면 IOBuf 패턴이 유용하다.

1
// header는 IOBuf로, body는 sendfile로 분리
2
socket->writeChain(std::move(headerBuf));
3
// 다음으로
4
::sendfile(socketFd, fileFd, &offset, bodySize);

또는 mmap된 file을 IOBuf로 wrap한다.

1
void* mapped = mmap(nullptr, size, PROT_READ, MAP_PRIVATE, fileFd, 0);
2
auto buf = folly::IOBuf::takeOwnership(
3
    mapped, size, [mapped, size] { munmap(mapped, size); });
4
// buf는 file의 page를 직접 가리킴, copy 없음
5
header->prependChain(std::move(buf));
6
socket->writeChain(std::move(header));

#패턴 5 — broadcast/fan-out

같은 buffer를 N개 receiver에 보낼 때.

1
auto data = ...;   // 큰 message
2

3
for (auto& client : clients) {
4
  auto cloned = data->clone();   // ref-count++, data 공유
5
  client->writeChain(std::move(cloned));
6
}

clone은 ref-count만 늘린다. N개 copy 대신 N개 reference다. memory도 시간도 절약된다.

#패턴 6 — pipe through transform

1
folly::IOBufQueue in_q, out_q;
2

3
void onDataReceived(folly::IOBuf data) {
4
  in_q.append(std::move(data));
5

6
  while (auto frame = parseFrame(in_q)) {
7
    auto transformed = transform(std::move(frame));   // 가능하면 IOBuf 반환
8
    out_q.append(std::move(transformed));
9
  }
10

11
  flushOut();
12
}

transformation이 byte 단위로 새 buffer를 만들지 않는 한, 전체 파이프라인이 zero-copy를 유지한다.

#SO_ZEROCOPY (Linux)

Linux 4.14+의 MSG_ZEROCOPY 플래그는 send()/sendmsg()가 user-space buffer를 kernel page에 직접 매핑해 보낸다. user → kernel copy도 0이 된다.

1
int one = 1;
2
setsockopt(fd, SOL_SOCKET, SO_ZEROCOPY, &one, sizeof(one));
3

4
iovec iov = {data, len};
5
msghdr msg = {.msg_iov = &iov, .msg_iovlen = 1};
6
sendmsg(fd, &msg, MSG_ZEROCOPY);
7
// 완료는 cmsg로 비동기 통보

Folly의 AsyncSocket은 setZeroCopy(true)로 이를 활성화한다. IOBuf chain이 그대로 kernel에 매핑된다.

#단점 — zero-copy의 비용

zero-copy가 항상 좋지는 않다.

작은 buffer(<4KB)는 copy 비용이 zero-copy setup 비용보다 낮다.
ref-count atomic operation 자체도 비용이다.
mmap/munmap 오버헤드가 크다.

벤치마크해서 실제 이득이 있는 임계점을 찾는다. 일반적으로 1KB 이상의 buffer에서 의미가 있다.

#코드 리뷰 포인트

writev/sendmsg가 IOBuf chain을 직접 받는가? 별도 buffer로 합치면 copy 발생.
header가 prepend되는가? chain 앞에 노드만 잇는다.
broadcast가 N copy? clone으로 ref-count 공유.
chain length가 너무 길지 않은가? iovec 한계(보통 1024) 초과면 multi-call 필요.

#자주 보는 안티패턴

1
// 1. chain을 single buffer로 합쳐서 write
2
auto coalesced = chain->coalesce();   // 전체 copy 1회
3
write(fd, coalesced.data(), coalesced.size());
4
// 옳음: writev에 chain 직접
5

6
// 2. clone 대신 copy
7
auto data = original->clone();   // ref-count
8
// vs
9
auto data = folly::IOBuf::copyBuffer(original->data(), original->length());   // copy
10

11
// 3. wrapBuffer 후 lifetime 미관리
12
std::string tmp = ...;
13
auto buf = folly::IOBuf::wrapBuffer(tmp.data(), tmp.size());
14
return buf;   // tmp 소멸 — dangling
15

16
// 4. zero-copy를 작은 message에 적용
17
for (auto& msg : small_messages) {   // 100B 짜리
18
  socket->writeChain(folly::IOBuf::takeOwnership(...));
19
  // 작은 메시지는 copy가 더 싸다
20
}

#std와 비교

표준에는 byte buffer chain이 없다. std::vector<std::span<std::byte>> 비슷한 구조를 만들 수 있지만 ref-count, prepend, splitting을 직접 구현해야 한다.

C++23의 std::span과 P2300 senders/receivers가 결합되면 비슷한 패턴이 표준화될 수 있다. 그러나 IOBuf만큼 풍부한 primitive는 당분간 표준에 없다.

#정리

IOBuf chain은 그 자체로 iovec다. writev/readv가 chain을 직접 처리한다.
recv는 IOBufQueue::preallocate로 zero-copy, send는 AsyncSocket::writeChain으로 zero-copy.
protocol layer stack은 prepend로 header를 복사 없이 잇는다.
broadcast는 clone()으로 ref-count 공유. N copy를 N ref로 바꾼다.
mmap된 file은 takeOwnership으로 IOBuf chain에 섞을 수 있다.
Linux SO_ZEROCOPY와 결합하면 user→kernel copy도 0이 된다.
작은 buffer는 zero-copy가 오히려 비싸다. 벤치마크로 확인.