C++ Stack Allocator | "스택 할당자" 가이드
이 글의 핵심
C++ Stack Allocator에 대한 실전 가이드입니다.
Stack Allocator란?
스택 메모리 할당자
template<typename T, size_t N>
class StackAllocator {
alignas(T) char buffer[N * sizeof(T)];
char* ptr = buffer;
public:
using value_type = T;
T* allocate(size_t n) {
if (ptr + n * sizeof(T) > buffer + sizeof(buffer)) {
throw std::bad_alloc();
}
T* result = reinterpret_cast<T*>(ptr);
ptr += n * sizeof(T);
return result;
}
void deallocate(T* p, size_t n) {
// 스택: 역순 해제만 지원
}
};스택 기반 할당이란 무엇인가
여기서 말하는 “스택 할당자”는 프로세스 스택 프레임이 아닌, 보통 스레드 스택 위에 깔거나 객체 안에 고정 버퍼를 두고 bump pointer로 쌓아 올리는 할당 방식을 가리키는 경우가 많습니다. std::vector<T, MyAlloc>에 붙이면, allocate가 미리 잡아 둔 연속 버퍼 안에서만 동작합니다. 진짜 alloca처럼 가변 길이를 스택에 깎아 쓰는 것과는 목적과 제약이 다릅니다.
표준적으로 비슷한 체험을 하려면 **std::pmr::monotonic_buffer_resource**에 스택 배열이나 thread_local 버퍼를 넘기는 패턴이 널리 쓰입니다(아래 “함수 로컬” 예시 참고).
alloca와 VLA(가변 길이 배열)
| 방식 | C++에서 | 특징 |
|---|---|---|
alloca | 사실상 비표준 확장(컴파일러별) | 스택에서 런타임 크기만큼 공간 확보. 실수로 큰 크기면 스택 오버플로. 예외 안전·이식성 나쁨. |
| VLA | C99. C++ 표준 아님 | GCC 등 확장으로 C++에서도 보이지만 이식성과 표준 준수 측면에서 비권장. |
현대 C++에서는 고정 상한이 있으면 std::array나 alignas 버퍼 + 커스텀 할당자, 상한을 모르면 std::vector 또는 pmr이 더 안전합니다.
메모리 풀과 비교
| 스택 버퍼 / 모노토닉 할당 | 메모리 풀(오브젝트 풀 등) | |
|---|---|---|
| 할당 속도 | 보통 매우 빠름(bump) | 미리 할당해 두면 빠름 |
| 해제 패턴 | LIFO 또는 영역 단위 리셋에 강함 | 특정 크기 블록 재사용에 강함 |
| 단편화 | 연속 버퍼라 거의 없음 | 풀 설계에 따라 다름 |
| 수명 | 스코프/리셋에 묶임 | 프로그램 수명 동안 유지 가능 |
| 적합한 경우 | 파싱 버퍼, 프레임 단위 임시 컨테이너 | 동일 크기 객체의 빈번한 new/delete |
한 줄 정리: “이번 호출 안에서만 쓰고 버릴 연속 메모리”면 스택 버퍼·모노토닉, “같은 타입 인스턴스를 반복 재사용”이면 풀을 고려합니다.
기본 사용
#include <vector>
int main() {
StackAllocator<int, 100> alloc;
std::vector<int, StackAllocator<int, 100>> vec{alloc};
for (int i = 0; i < 10; ++i) {
vec.push_back(i);
}
}실전 예시
예시 1: 고정 버퍼
template<typename T, size_t N>
class FixedStackAllocator {
alignas(T) char buffer[N * sizeof(T)];
size_t used = 0;
public:
using value_type = T;
T* allocate(size_t n) {
if (used + n > N) {
throw std::bad_alloc();
}
T* ptr = reinterpret_cast<T*>(buffer + used * sizeof(T));
used += n;
return ptr;
}
void deallocate(T* p, size_t n) {
// LIFO만 지원
if (reinterpret_cast<char*>(p) + n * sizeof(T) ==
buffer + used * sizeof(T)) {
used -= n;
}
}
void reset() {
used = 0;
}
};예시 2: 스택 벡터
template<typename T, size_t N>
class StackVector {
alignas(T) char buffer[N * sizeof(T)];
size_t count = 0;
public:
void push_back(const T& value) {
if (count >= N) {
throw std::bad_alloc();
}
void* slot = buffer + count * sizeof(T);
::new (slot) T(value);
++count;
}
T& operator[](size_t i) {
return *reinterpret_cast<T*>(&buffer[i * sizeof(T)]);
}
size_t size() const { return count; }
~StackVector() {
for (size_t i = 0; i < count; ++i) {
(*this)[i].~T();
}
}
};
int main() {
StackVector<int, 100> vec;
vec.push_back(1);
vec.push_back(2);
}예시 3: 임시 할당
template<typename T, size_t N>
class TempAllocator {
alignas(T) char buffer[N * sizeof(T)];
char* ptr = buffer;
public:
using value_type = T;
T* allocate(size_t n) {
if (ptr + n * sizeof(T) <= buffer + sizeof(buffer)) {
T* result = reinterpret_cast<T*>(ptr);
ptr += n * sizeof(T);
return result;
}
// 버퍼 부족 시 힙 사용
return static_cast<T*>(::operator new(n * sizeof(T)));
}
void deallocate(T* p, size_t n) {
if (reinterpret_cast<char*>(p) >= buffer &&
reinterpret_cast<char*>(p) < buffer + sizeof(buffer)) {
// 스택: 해제 안 함
} else {
::operator delete(p);
}
}
};예시 4: 함수 로컬
#include <vector>
void processData() {
// 로컬 버퍼
char buffer[4096];
std::pmr::monotonic_buffer_resource mbr{buffer, sizeof(buffer)};
std::pmr::vector<int> tempVec{&mbr};
// 임시 데이터 처리
for (int i = 0; i < 100; ++i) {
tempVec.push_back(i * i);
}
// 함수 종료 시 자동 해제
}제약사항 정리
- 용량 상한: 고정 버퍼를 넘으면
bad_alloc또는 힙 폴백 설계가 필요합니다. - LIFO/역순 해제: 범용
allocate/deallocate를 정확히 지원하려면 할당 순서 제약을 문서화해야 합니다. - 이동·복사:
std::vector와 커스텀 할당자를 쓸 때는 allocator-aware 요구사항과 propagate_on_container_move_assignment 등을 이해해야 합니다(표준 컨테이너는 구현이 복잡함). - 스레드: 스택 버퍼가 스레드 로컬이 아니면 동시 접근 시 데이터 레이스입니다.
- 디버그:
reinterpret_cast와 수동 수명 관리(placement new)는 UB 가능성이 있으므로 코드 리뷰와 테스트가 중요합니다.
실전 활용(추가 아이디어)
- JSON/XML 파싱 등 한 번의
parse()호출 안에서만 필요한vector/string을 PMR 버퍼에 얹기. - 오디오·그래픽스: 프레임 단위 임시 샘플 버퍼(크기 상한 알 때).
- 임베디드·실시간: 힙 사용을 피하기 위해 정적 버퍼 + 모노토닉으로 STL 컨테이너 사용.
장점
// 1. 빠른 할당
// - 스택 메모리
// - 시스템 호출 없음
// 2. 캐시 친화적
// - 지역 메모리
// 3. 자동 해제
// - 스코프 종료 시
// 4. 단편화 없음자주 발생하는 문제
문제 1: 크기 제한
// ❌ 스택 오버플로우
StackAllocator<int, 1000000> alloc; // 너무 큼
// ✅ 적절한 크기
StackAllocator<int, 1000> alloc;
// 또는 힙 폴백문제 2: 수명
// ❌ 스코프 벗어남
std::vector<int, StackAllocator<int, 100>>* getVector() {
StackAllocator<int, 100> alloc; // 지역 변수
return new std::vector<int, StackAllocator<int, 100>>{alloc};
// alloc 소멸
}
// ✅ 수명 보장문제 3: LIFO
// 스택 할당자는 LIFO만 효율적
StackAllocator<int, 100> alloc;
int* p1 = alloc.allocate(10);
int* p2 = alloc.allocate(10);
// ✅ 역순 해제
alloc.deallocate(p2, 10);
alloc.deallocate(p1, 10);
// ❌ 순서 바뀜
// alloc.deallocate(p1, 10); // 비효율문제 4: 재할당
// 벡터 재할당 시 문제
std::vector<int, StackAllocator<int, 100>> vec{alloc};
vec.reserve(50); // 스택 할당
vec.reserve(200); // 버퍼 부족 -> 예외 또는 힙활용 패턴
// 1. 임시 데이터
void process() {
StackAllocator<int, 1000> alloc;
std::vector<int, StackAllocator<int, 1000>> temp{alloc};
}
// 2. 작은 컨테이너
StackVector<int, 10> small;
// 3. 함수 로컬
char buffer[4096];
std::pmr::monotonic_buffer_resource mbr{buffer, sizeof(buffer)};
// 4. 성능 최적화
// 빈번한 할당/해제FAQ
Q1: Stack Allocator?
A: 스택 메모리 할당자.
Q2: 장점?
A:
- 빠른 할당
- 캐시 친화적
- 자동 해제
Q3: 크기?
A: 고정. 스택 제한.
Q4: LIFO?
A: 역순 해제만 효율적.
Q5: 용도?
A: 임시 데이터, 작은 컨테이너.
Q6: 학습 리소스는?
A:
- “Effective C++”
- “Game Programming Patterns”
- cppreference.com
같이 보면 좋은 글 (내부 링크)
이 주제와 연결되는 다른 글입니다.
- C++ Memory Pool | “메모리 풀” 가이드
- C++ Custom Allocator | “커스텀 할당자” 가이드
- C++ Cache Optimization | “캐시 최적화” 가이드
관련 글
- C++ Cache Optimization |
- C++ Custom Allocator |
- C++ Memory Pool |
- C++ Algorithm Sort |
- C++ Allocator |